首页 > 试题广场 >

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

[编程题]从单向链表中删除指定值的节点
  • 热度指数：140217 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
  • 算法知识视频讲解
\hspace{15pt}定义一种单向链表的构造方法如下所示：
\hspace{23pt}\bullet\,先输入一个整数 n ，代表链表中节点的总数；
\hspace{23pt}\bullet\,再输入一个整数 h ，代表头节点的值；
\hspace{23pt}\bullet\,此后输入 n-1 个二元组 \left(a, b\right) ，表示在值为 b 的节点后插入值为 a 的节点。
\hspace{15pt}除此之外，保证输入的链表中不存在重复的节点值。

\hspace{15pt}现在，对于给定的链表构造方法和一个额外的整数 k ，你需要先按照上述构造方法构造出链表，随后删除值为 k 的节点，输出剩余的链表。

输入描述:
\hspace{15pt}在一行上：
{\hspace{20pt}}_\texttt{1.}\,先输入一个整数 n \left(1 \leqq n \leqq 10^3\right) 代表链表中节点的总数；
{\hspace{20pt}}_\texttt{2.}\,随后输入一个整数 h \left(1 \leqq h \leqq 10^4\right) 代表头节点的值；
{\hspace{20pt}}_\texttt{3.}\,随后输入 n-1 个二元组 \left(a, b\right) \left(1 \leqq a, b \leqq 10^4\right) ；
{\hspace{20pt}}_\texttt{4.}\,最后输入一个整数 k ，代表需要删除的节点值。

\hspace{15pt}除此之外，保证每一个 b 值在输入前已经存在于链表中；每一个 a 值在输入前均不存在于链表中。节点的值各不相同。


输出描述:
\hspace{15pt}在一行上输出 n-1 个整数，代表删除指定元素后剩余的链表。
示例1

输入

5 2 3 2 4 3 5 2 1 4 3

输出

2 5 4 1

说明

\hspace{15pt}在这个样例中，链表的构造过程如下：
\hspace{23pt}\bullet\,头节点为 2 ，得到链表 \left[{\color{orange}{\bf 2}}\right] ；
\hspace{23pt}\bullet\,在 2 后插入 3 ，得到链表 \left[2, {\color{orange}{\bf 3}}\right] ；
\hspace{23pt}\bullet\,在 3 后插入 4 ，得到链表 \left[2, 3, {\color{orange}{\bf 4}}\right] ；
\hspace{23pt}\bullet\,在 2 后插入 5 ，得到链表 \left[2, {\color{orange}{\bf 5}}, 3, 4\right] ；
\hspace{23pt}\bullet\,在 4 后插入 1 ，得到链表 \left[2, 5, 3, 4, {\color{orange}{\bf 1}}\right] ；
\hspace{15pt}随后，删除值为 3 的节点，得到链表 \left[2, 5, 4, 1\right] 。
示例2

输入

6 2 1 2 3 2 5 1 4 5 7 2 2

输出

7 3 1 5 4

说明

\hspace{15pt}在这个样例中，链表的构造过程如下：
\hspace{23pt}\bullet\,头节点为 2 ，得到链表 \left[{\color{orange}{\bf 2}}\right] ；
\hspace{23pt}\bullet\,在 2 后插入 1 ，得到链表 \left[2, {\color{orange}{\bf 1}}\right] ；
\hspace{23pt}\bullet\,在 2 后插入 3 ，得到链表 \left[2, {\color{orange}{\bf 3}}, 1\right] ；
\hspace{23pt}\bullet\,在 1 后插入 5 ，得到链表 \left[2, 3, 1, {\color{orange}{\bf 5}}\right] ；
\hspace{23pt}\bullet\,在 5 后插入 4 ，得到链表 \left[2, 3, 1, 5, {\color{orange}{\bf 4}}\right] ；
\hspace{23pt}\bullet\,在 2 后插入 7 ，得到链表 \left[2, {\color{orange}{\bf 7}}, 3, 1, 5, 4\right] ；
\hspace{15pt}随后，删除值为 2 的节点，得到链表 \left[7, 3, 1, 5, 4\right] 。

备注:
\hspace{15pt}本题由牛客重构过题面，您可能想要阅读原始题面，我们一并附于此处。
\hspace{15pt}【以下为原始题面】
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1

3 2表示为
2->3
链表为2->3->1

5 1表示为
1->5
链表为2->3->1->5

4 5表示为
5->4
链表为2->3->1->5->4

7 2表示为
2->7
链表为2->7->3->1->5->4

最后的链表的顺序为 2 7 3 1 5 4

最后一个参数为2，表示要删掉节点为2的值
删除 结点 2
则结果为 7 3 1 5 4

数据范围：链表长度满足  ，节点中的值满足 

测试用例保证输入合法
算法知识视频讲解
添加回答
C
墨夜风名头像 墨夜风名 
#include <stdio.h>
#include <stdlib.h>

struct Item {
    int value;
    struct Item* next;
};

//2
int insertValue(struct Item* head, int cur, int prev) { // 4 1
    struct Item* next = head;
    for (; next != 0; next = next->next) {
        if (prev == next->value) {
            break;
        }
    }

    if (0 == next) {
        return -1;
    }

    struct Item* temp = malloc(sizeof(struct Item));
    temp->value = cur;
    temp->next = next->next;
    next->next = temp;

    return 0;
}
// 2 5 3 4 1
int deleteValue(struct Item **head, int value) {
    struct Item *next = *head;
    struct Item *prev = *head;

    for (; next != 0; next = next->next) { //2,5,3,4
        if (value == next->value) {
            break;
        }
        prev = next;//2,5,3,4
    }

    if(0 == next){
        printf("error:can't found %d in list\n", value);
        return -1;
    }else if(*head == next){
        struct Item *temp = (*head)->next;
        free(*head);
        *head = temp;
        return 0;
    }else {
        prev->next = next->next;
        free(next);
    }

    return 0;
}

void printList(struct Item* head) {
    struct Item* next = head;
    for (; next != 0; next = next->next) {
        printf("%d ", next->value);
    }
    printf("\n");
}

int main() {
    int total;
    int value;
    struct Item* head = 0;

    //5 2  3 2 4 3 5 2 1 4 1
    scanf("%d", &total); //5
    scanf("%d", &value); //2

    head = malloc(sizeof(struct Item));
    head->value = value;
    head->next = 0;

    total--;
    while (total--) {
        int cur;
        int prev;
        scanf("%d %d", &cur, &prev);
        insertValue(head, cur, prev);
    }
    
    int delete;

    scanf("%d", &delete);
    deleteValue(&head, delete);

    printList(head);

    return 0;
}

发表于 2024-02-26 12:51:45 回复(0)
C
彭洋a头像 彭洋a
#include <stdio.h>
#include <stdlib.h>

typedef struct slist
{
    int val;
    struct slist* next;
}sl;

int main() {
    int n = 0;
    while (scanf("%d", &n) != EOF) {
        sl* head = (sl*)malloc(sizeof(sl));
        if (head == NULL)
        {
            printf("malloc fail\n");
            exit(-1);
        }
        scanf("%d", &head->val);
        head->next = NULL;
        sl* ptr = head;
        for (int i = 0; i < n-1; i++)
        {
            int now = 0;
            int pre = 0;
            sl* node = (sl*)malloc(sizeof(node));
            scanf("%d %d", &now, &pre);
            node->val = now;
            node->next = NULL;
            ptr = head;
            while (ptr)
            {
                if (ptr->val == pre)
                {
                    if (ptr->next == NULL)
                    {
                        ptr->next = node;
                        break;
                    }
                    else
                    {
                        sl* next = ptr->next;
                        ptr->next = node;
                        node->next = next;
                        break;
                    }

                }
                ptr = ptr->next;
            }

        }
        int era = 0;
        scanf("%d", &era);
        ptr = head;
        int flag = 0;
        while (ptr)
        {
            if (ptr->val != era)
            {
                printf("%d ", ptr->val);
                flag = 1;
            }
            ptr = ptr->next;
        }
        if (flag == 0)
        {
            printf("NULL");
        }
        ptr = head;
        while (ptr)
        {
            ptr = head->next;
            free(head);
            head = ptr;
        }
    }
    return 0;
}
发表于 2023-10-18 12:23:21 回复(0)
C
牛客364244344号头像 牛客364244344号 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct NodeList{
    int val;
    struct NodeList* next;
}*List, Node;

void InsertNode(List L, int curVal, int beforeVal)
{
    Node* node = (Node*)malloc(sizeof(Node));
    node->val = curVal;
    List p = L;
    p = p->next;
    while(p != NULL){
        if(p->val == beforeVal){
            node->next = p->next;
            p->next = node;
            break;
        }else{
            p = p->next;
        }
    }
}

void DeleteVal(List L, int val)
{
    List p = L;
    while(p->next != NULL){
        if(p->next->val == val){
            p->next = p->next->next;
            break;
        }
        p = p->next;
    }

}

int main()
{
    int n;
    List L = (List)malloc(sizeof(Node));
    int head;
    int delVal;
    scanf("%d", &n);
    scanf("%d", &head);
    L->val = 0;
    Node* headNode = (Node*)malloc(sizeof(Node));
    headNode->val = head;
    headNode->next = NULL;
    L->next = headNode;
    for(int i = 1; i < n; i++){
        int beforeVal, curVal;
        scanf("%d %d", &curVal, &beforeVal);
        InsertNode(L, curVal, beforeVal);
    }
    scanf("%d", &delVal);
    DeleteVal(L, delVal);
    L = L->next;
    while(L != NULL){
        printf("%d ", L->val);
        L = L->next;
    }
    return 0;
}

发表于 2023-10-07 21:21:16 回复(0)
C
planetlight头像 planetlight
#include <stdio.h>
#include <stdlib.h>

typedef struct listnode{
    struct listnode *next;
    int val;
}list, *listpoint;

listpoint list_create(int x){
    listpoint newcode=(listpoint)malloc(sizeof(list));
    newcode->next=NULL;
    newcode->val=x;
    return newcode;
}

void list_add(listpoint lhead,int a,int b){
    listpoint p=lhead;
    while (p) {
        if(p->val==b){
            listpoint newcode=(listpoint)malloc(sizeof(list));
            newcode->val=a;
            newcode->next=p->next;
            p->next=newcode;
            break;
        }
        p=p->next;
    }
}

 void list_del(listpoint *lhead,int x){
    listpoint pre=NULL;
    listpoint now=*lhead;
    while (now) {
        if((*lhead)->val==x){
            *lhead=(*lhead)->next;
            free(now);
            now=*lhead;
        }
        else{
            if(now->val==x){
                pre->next=now->next;
                free(now);
                now=pre->next;
            }
            else{
                pre=now;
                now=now->next;
            }
        }
    }
}

void list_print(listpoint lhead){
    while (lhead) {
        printf("%d ",lhead->val);
        lhead=lhead->next;
    }
    printf("\n");
}

int main() {
    int num=0;
    scanf("%d",&num);
    int headnum=0;
    scanf("%d",&headnum);
    listpoint lhead=list_create(headnum);
    int i=1;
    while(i<num){
        int a=0,b=0;
        scanf("%d",&a);
        scanf("%d",&b);
        list_add(lhead,a,b);
        i++;
    }
    int del=0;
    scanf("%d",&del);
    list_del(&lhead, del);
    list_print(lhead);

    return 0;
}

发表于 2023-05-22 19:31:24 回复(0)
C
初牛小客头像 初牛小客 
#include <stdio.h>
#include <string.h>

typedef struct Node {   //链表定义
    int data;
    struct Node* next;
}* LinkList, LNode;

void Add(LinkList L, int n1, int n2) { //在值为n1的节点后插入值为n2的节点
    LNode* nextNode = (LNode*)malloc(sizeof(LNode));
    nextNode->data = n2;
    nextNode->next = NULL;

    LNode* p = L->next;   //记录第一个元素
    while (p) {
        if (p->data == n1) {
            nextNode->next = p->next;
            p->next = nextNode;
            break;
        } else {
            p = p->next;
        }
    }
}

void Delete(LinkList L, int n3) {   //删除值为n3的节点
    LNode* prior = L;     //记录前一个元素
    LNode* p = L->next;   //记录当前元素
    while (p) {
        if (p->data == n3) {
            prior->next = p->next;
            free(p);
            p = NULL;
            break;
        } else {
            prior = p;
            p = p->next;
        }
    }
}

int main() {
    int n, first_value;
    scanf("%d %d", &n, &first_value);
    LinkList L = (LNode*)malloc(sizeof(LinkList));
    L->next = NULL;                  //初始化表头结点
    L->data = 0;

    LNode* firstNode = (LNode*)malloc(sizeof(LNode));  //插入第一个元素
    firstNode->data = first_value;
    firstNode->next = NULL;
    L->next = firstNode;

    for (int i = 0; i < n - 1; i++) {
        int next_value = 0;
        int now_value = 0;
        int de_value = 0;
        scanf("%d %d", &next_value, &now_value);
        Add(L, now_value, next_value);
        if (i == n - 2) {
            scanf("%d", &de_value);
            Delete(L, de_value);
        }
    }

    //打印输出最后的结果
    while (L->next) {
        printf("%d ", L->next->data);
        L = L->next;
    }
    return 0;
}

发表于 2023-02-28 21:12:55 回复(0)
C
不知道起什么名字。。。头像 不知道起什么名字。。。 
#include <stdio.h>

struct NODE
{
  int value;
  struct NODE *next;
};
struct NODE *head, *cur;

int main()
{
  int i, j, k, m, n;
  
  scanf("%d ", &n);

  struct NODE node[n];
  memset(node, 0x00, sizeof(node));
  
  scanf("%d ", &node[0].value);
  node[0].next = NULL;
  head = &node[0];
  k = 1;
  
  // 节点依次加入
  for(i = 1; i < n; i++)
  {
    scanf("%d %d", &node[k].value, &m);
    
    if(m == head->value)
    {
      node[k].next = head->next;
      head->next = &node[k];
    }
    else
    {
      cur = head;
      while(1)
      {
        cur = cur->next;
        if(m == cur->value)
        {
          node[k].next = cur->next;
          cur->next = &node[k];
          break;
        }
      }
    }
    
    k++;
  }
 
  // 删除对应的节点
  scanf("%d", &m);
  
  if(m == head->value)
  {
    head = head->next;
  }
  else
  {
    cur = head;
    while(1)
    {
      if(m == cur->next->value)
      {
        cur->next = cur->next->next;
        break;
      }
      
      cur = cur->next;
    }
  }
  
  cur = head;
  while(cur)
  {
    printf("%d ", cur->value);
    cur = cur->next;
  }
}

发表于 2022-08-28 17:59:43 回复(0)
C
牛客365947315号头像 牛客365947315号 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
    int N, x, y, z, m, n,
        p; //x第一个；y，z连续接收两个；m遍历数组的序号;n为删除节点
    scanf("%d", &N);
    int a[N];
    scanf("%d", &x);
    a[0] = x;
    int length = 1;
    for (int i = 0; i < N - 1; i++) {
        scanf("%d %d ", &y, &z);
        for (m = 0; m < length; m++) {
            if (a[m] == y) {
                for (int o = length; o > m; o--) {
                    a[o] = a[o - 1];
                }
                a[m] = z;
                length++;
                break;
            } else if (a[m] == z) {
                for (int o = length; o > m + 1; o--) {
                    a[o] = a[o - 1];
                }
                a[m + 1] = y;
                length++;
                break;
            }
        }
    }
    scanf("%d", &n);
    for (int i = 0; i < length - 1; i++) {
        if (a[length - 1] == n) {
            length --;
            break;
        } else if (a[i] == n) {
            for (; i < length; i++)
                a[i] = a[i + 1];
            length--;
            break;
        }
    }
    for (p = 0; p < length; p++)
        printf("%d ", a[p]);
}


发表于 2022-06-03 12:52:13 回复(0)
C
已注销头像 已注销 
#include <stdio.h>
#include <stdlib.h>
typedef struct list
{
    int num;
    struct list *next;
}list;
int main()
{
    int cnt,del,i,j;
    list *p0=malloc(sizeof(list)),*p1,*p2;
    scanf("%d%d",&cnt,&p0->num);
    p0->next=NULL;
    cnt--;
    while(cnt>0)
    {
        scanf("%d%d",&i,&j);
        p1=p0;
        while(p1!=NULL)
        {
            if(p1->num==j)
            {
                p2=malloc(sizeof(list));
                p2->num=i;
                p2->next=p1->next;
                p1->next=p2;
                break;
            }
            p1=p1->next;
        }
        cnt--;
    }
    scanf("%d",&del);
    p1=p0;
    p2=p0->next;
    if(p1->num==del)
        p0=p0->next;
    else
    {
        while(p2!=NULL)
        {
            if(p2->num==del)
            {
                p1->next=p2->next;
                break;
            }
            p1=p2;
            p2=p2->next;
        }
    }
    p1=p0;
    while(p1!=NULL)
    {
        printf("%d ",p1->num);
        p1=p1->next;
    }
    return 0;
}

发表于 2022-04-28 18:52:22 回复(0)
C
SnowJade头像 SnowJade 
#include <stdio.h>
#include <stdlib.h>
#define  max_array  10000  


typedef struct node
{
    int data;
    struct node *prev;
    struct node *next;
}node;

int d;
node *delete_node(node *head,int del);
int main()
{
    int num = 0;
    scanf("%d",&num);
    int a[max_array]={0};
    int i = 0;
    for(i=0; i < num*2;i++)
    {
        scanf("%d",&a[i]);
    }//a[0] is head,a[num*2 -1] is delete;

    for(i=0;i < num*2;i++)
    {
        //printf ("%d ",a[i]);
    }


    


    node *head = malloc(sizeof(node));
    head->data = a[0];
    head->next = NULL;
    head->prev = NULL;
    //printf("head->data == %d\n",head->data);
    int bfn = 0;
    for(i =1 ; i< num*2 -1;i+=2)
    {
        //printf("i == %d\n",i);
        node *n = malloc(sizeof(node));
        n->data = 0;
        n->next = NULL;
        n->prev = NULL;

        n->data = a[i];
        //printf("n->data == %d\n",n->data);
        bfn = a[i+1];
        //printf("bfn == %d\n",bfn);
        if(head->data == bfn)
        {
            //printf("head->data == bfn\n");
            if(head ->next ==NULL)
            {
                head->next = n;
                n->prev = head;
                continue;
            }
            else
            {
                //printf("!!!!!!!!n->data = %d\n",n->data);
                //n->next = head->next;
                //printf("these head->next == %d\n",head->next->data); //should be 1
                node *linshi =head->next;
                n->next =linshi;
                n->prev =head;
                 //printf("these linshi->data %d\n",linshi->data); 
                linshi ->prev = n;
                head->next = n;
                //printf("n->next->data =%d\n",n->next->data);
                //printf("n->prev->data = %d\n",n->prev->data);
                //printf("n->prev->next->data = %d\n",n->prev->next->data);
                //printf("n->next->prev->data = %d\n",n->prev->next->data);
                continue;
            }//end of if(head ->next ==NULL)
        }//end of if(head->data == bfn)
        node *search =head->next;
       // printf("search->data == %d\n",search->data);
       // printf("before while   bfn == %d\n",bfn);
        while(1)
        {
          //  printf("while here!!\n");
          //  printf("while here!! search->data ==%d\n",search->data);
          //  printf("while   bfn == %d\n",bfn);
            if(bfn == search->data)
            {
                if(search->next)
                {
                    n->next =search->next;
                    search->next->prev =n;
                }
                search->next = n;
                n->prev=search;
                
                break;
            }
            if(search->next !=NULL)
            {
               // printf("in while before search->data ==%d\n",search->data);
                search  = search->next;
              //  printf("in while after search->data ==%d\n",search->data);
            }
            else
            {
                //printf("invalid before node num!\n");
                return 0;
            }
        }//end of while(1)

        
    }//end offor(i =1 ; i< num*2 -1;i+=2)


    
    node *prin = head;
    while(1)
    {
        //printf("%d  ",prin->data);
        if(prin->next != NULL)
        {
            prin = prin->next;
        }
        else
        {
          //  printf("\n");
            break;
        }
        
    }
    
    d = a[num *2 -1]; //the delete node->data
    //delete_node(head,d);
    //printf("d == %d\n",d);
    prin = delete_node(head,d);
    //printf("niubi\n");
    while(1)
    {
        printf("%d ",prin->data);
        if(prin->next != NULL)
        {
            prin = prin->next;
        }
        else
        {
            //printf("\n");
            break;
        }
        
    }
    
}


node *delete_node(node *head,int del)
{
    node *delete = head;
    node *tmp = delete;
    //printf("delete == tmp ==%d\n",delete->data);
    while(1)
    {
        if(delete->data == d)
        {
            //printf("1111111\n");
            if(delete->prev && delete->next)
            {
               // printf("22222222\n");
                tmp = delete->next;
                delete->prev->next = delete->next;
                delete->next->prev = delete->prev;
                free(delete);
                delete =tmp;
                continue;
            }
            else if(delete->prev == NULL && delete->next != NULL)
            {
                //printf("333333333\n");
                tmp = delete->next;
                delete->next->prev =NULL;
                free(delete);
                delete =tmp;
            }
        }
        if(delete -> next)
        {
            //printf("44444444\n");
            delete = delete->next;
        }
        else
        {
            while(1)
            {
               // printf("555555555\n");
                if(delete->prev)
                {
                    //printf("666666666\n");
                    delete  = delete->prev;
                }
                else
                {
                    break;
                }
            }
            //printf("7777777\n");
            return delete;
        }
    }
}

发表于 2022-04-23 17:31:01 回复(0)
C
牛客250632461号头像 牛客250632461号
这题目出的跟神经病一样  语句不通
发表于 2022-03-27 09:58:20 回复(0)
C
Hey2333777头像 Hey2333777 
#include
int main()
{
    //Input number of points & value of first number
    int num;
    int fir;
    scanf("%d %d",&num,&fir);
    int sum[1000]={0};
    sum[0]=fir;

    //Input two numbers per time
    int i=1;
    while(i<num)//Times of while loop
    {
        int n1=0,n2=0;
        scanf("%d %d",&n1,&n2);

        //Detect points and input new points
        for(int j=0; j<num; j++)
        {
            if(sum[j]==n2)
            {
                //Detect whether there is a value
                if(sum[j+1]==0)
                {
                    sum[j+1]=n1;//If not, input new points
                }
                else
                {
                    for(int k=i; k>j+1; k--)
                    {
                        sum[k]=sum[k-1];//If there is, move all point back for one place
                    }
                    sum[j+1]=n1;
                }
            }
        }
        i++;
    }

    //Delete value of late number in string
    int del;
    scanf("%d", &del);
    for(int i=0; i<num; i++)
    {
        if(sum[i]==del)
        {
            for(int j=i; j<num; j++)
            {
                sum[j]=sum[j+1];//If there is a deleted point, all points behind it should move toward for one place
            }
            num--;//And number of string should minus one
        }
    }

    //Output the final string
    for(int i=0; i<num; i++)
    {
        printf("%d ",sum[i]);
    }
}
发表于 2021-12-12 23:20:53 回复(0)
C
致爱丽丝头像 致爱丽丝
插入值没有插在头节点之前的，注意删除值的时候可能会删掉头节点。 
#include <stdio.h>
#include <stdlib.h>

typedef struct node{
    int num;
    struct node* next;
}Node;

Node *createnode(int num);
void addnode(int num1,int num2,Node *head);
Node *deletenode(int num,Node *head);
void printlist(Node *head);
void myfunc(int index,int headnum);

int main(void)
{
    int index,headnum;
    while(scanf("%d %d",&index,&headnum) == 2){
        myfunc(index,headnum);
    }
    
    return 0;
}

Node *createnode(int num)
{
    Node *pt;
    pt = (Node*)malloc(sizeof(Node));
    pt->num = num;
    pt->next = NULL;
    return pt;
}

void addnode(int num1,int num2,Node *head)
{
    Node *now,*add;
    now = head;
    
    while(now->num != num2) now = now->next;    //找到num2
    add = createnode(num1);

    add->next = now->next;
    now->next = add;
}

Node *deletenode(int num,Node *head)
{
    Node *now,*pre;
    now = head,pre = head;
    
    while(now->num != num){
        pre = now;
        now = now->next;    //找到num
    }
    
    if(now  == head){
        head = head->next;    //如果删除的是头部节点
    }else{
        pre->next = now->next;
    }
    free(now);
    return head;        //删除节点有可能改变头节点的位置，所以要返回头节点
}

void printlist(Node *head)
{
    Node * now;
    for(now = head;head != NULL;head = now){
        printf("%d ",head->num);
        now = head->next;
        free(head);
    }
    printf("\n");
    
}

void myfunc(int index,int headnum)
{
    int num,add;
    int i;
    
    Node *head = createnode(headnum);
    for(i=0;i<index-1;i++){
        scanf("%d %d",&add,&num);
        addnode(add, num, head);
    }
    scanf("%d",&num);
    head = deletenode(num,head);
    printlist(head);
}
发表于 2021-11-10 16:51:18 回复(0)
C
牛客354105004号头像 牛客354105004号
#include<stdio.h>
int insert(int *list, int len, int index, int num) {
    if (index > len || len > num) {
        return 0;
    }
    for (int i = len - 1; i > index; i--) {
        list[i+1] = list[i];
    }
    return 1;
}

int main() {
    int num = 0;
    scanf("%d", &num);
    int list[num];
    scanf("%d", &list[0]);
    int arr , tmp;
    int len = 1;
    for (int i = 0; i < num - 1; i++) {
        scanf("%d %d", &arr, &tmp);
        for (int j = 0; j < len; j++) {
            if (list[j] == tmp) {
                if (insert(list, len, j, num) == 1) {
                    len ++;
                }
                list[j+1] = arr;
                continue;
            }
        }
    }
    int target;
    int target_index = num;
    scanf ("%d", &target);
    for(int i = 0; i < num; i++) {
        if (list[i] == target) {
            target_index = i;
        }
    }
    if (target_index != num) {
        for (int i = 0; i < num; i++) {
            if (i != target_index) {
                printf("%d ",list[i]);
            }
        }
    }
    return 0;
}
c确实麻烦，有点挫
发表于 2021-09-17 22:07:39 回复(0)
C
牛客564209350号头像 牛客564209350号 
#include <stdio.h>
#define maxsize 700

void insert(int position, int num, int *p, int size)
{
    for(int i = 0; i < size; i++)
    {
        if(*(p + i) == position)
        {
            for(int j = size - 1; j > i; j--)
            {
                *(p + j + 1) = *(p + j);
            }
            *(p + i + 1) = num;
        }
    }
}

void deletenum(int position, int *p, int size)
{
    for(int i = 0; i < size + 1; i++)
    {
        if(*(p + i) == position)
        {
            for(int j = i; j < size + 1; j++)
            {
                *(p + j) = *(p + j + 1);
            }
        }
    }
}

int main()
{
    int num = 0;
    int input[maxsize];
    int head = 0;
    int next = 0;
    int delete = 0;
    int position = 0;
    
    while(scanf("%d", &num) != EOF)
    {
        head = 0;
        delete = 0;
        next = 0;
        position = 0;
        
        for(int i = 0; i < maxsize; i++)
            input[i] = 0;
        scanf("%d", &head);
        input[0] = head;
        for(int i = 0; i < num - 1; i++)
        {
            scanf("%d", &next);
            scanf("%d", &position);
            insert(position, next, input, num);
        }
        scanf("%d", &delete);
        deletenum(delete, input, num);
        
        for(int i = 0; i < num - 1; i++)
        {
            printf("%d ", input[i]);
        }
        printf("\n");
    }
}



没有用到链表，用数组顺序做链表

发表于 2021-08-21 20:09:12 回复(0)
C
80后大叔头像 80后大叔 
#include<stdio.h>

int main() {
    int in[5000] = {0};
    int num = 0;
    while(scanf("%d ", &in[num]) != EOF) {
        num++;
    }
    typedef struct lian {
        int value;
        struct LIAN *next; 
    }LIAN;
    LIAN *head, *normal;
    // 创建第一个节点
    head = (LIAN*)malloc(sizeof(LIAN));
    head->value = in[1];
    // 创建第二个节点
    normal = (LIAN*)malloc(sizeof(LIAN));
    normal->value = in[2];
    normal->next = NULL;
    head->next = normal;
    LIAN *p = head;
    // 创建后续的节点
    for (int i = 4; i < num-2; i=i+2) {
        p = head;
        while(p != NULL) {
            if(p->value == in[i+1]) {
                LIAN *temp = p->next;
                normal = (LIAN*)malloc(sizeof(LIAN));
                normal->value = in[i];
                p->next = normal;
                normal->next = temp;
                break;
            } else {
                p = p->next;
            }
        }
    }
    // 删除节点
    p = head;
    while(p->next != NULL) {
        LIAN *temp = p->next;
        if(temp->value == in[num-1]) {
            p->next = temp->next;
            break;
        }
        p = p->next;
    }
    // 输出链表
    p = head;
    while(p->next != NULL) {
        printf("%d ", p->value);
        p = p->next;
    }
    printf("%d", p->value);
}
发表于 2021-08-15 22:37:31 回复(0)
C
胖墩墩的ssr在冲浪头像 胖墩墩的ssr在冲浪 
#include <stdio.h>
#include <string.h>
typedef struct node
{
    int _data;
    struct node* _next;
}Node;
//创建头结点
Node* creatHeadNode(int data)
{
    Node* head = (Node*)malloc(sizeof(Node));
    head->_data = data;
    head->_next = NULL;
    return head;
}
//插入节点
Node* insertNode(Node* head, int data, Node* tmp)
{
    Node* cur = (Node*)malloc(sizeof(Node));
    cur->_data = data;
    cur->_next = tmp->_next;
    tmp->_next = cur;
    return head;
}
//删除节点
Node* deletNode(Node* head, int data)
{
    Node* tmp;
    if(head->_data == data)
    {
        tmp = head->_next;
        free(head);
        return tmp;
    }
    else
    {
        tmp = head;
        while(tmp->_next->_data != data)
            tmp = tmp->_next;
        Node* cur = tmp->_next;
        tmp->_next = cur->_next;
        free(cur);
        return head;
    }
}
//查找
Node* searchNode(Node* head, int find)
{
    Node* tmp = head;
    while(tmp->_data != find)
        tmp = tmp->_next;
    return tmp;
}
int main()
{
    int arr[2000];
    int n;
    scanf("%d", &n);
    arr[0] = n;
    int len = (n-1)*2+3;
    for(int i=1;i<len; i++)
        scanf("%d", &(arr[i]));
    Node* head = creatHeadNode(arr[1]);
    for(int i=2; i<len-1; i+=2)
    {
        Node* cur = searchNode(head, arr[i+1]);
        insertNode(head, arr[i], cur);
    }
    deletNode(head, arr[len-1]);
    int th = (len-3)/2;
    Node* tmp = head;
    for(int i=0; i<th; i++)
    {
        printf("%d ", tmp->_data);
        tmp = tmp->_next;
    }
    return 0;
}

发表于 2021-08-12 23:13:28 回复(0)
提交观点

问题信息

链表
来自：华为机试编程模拟题4
难度：
16条回答 47735浏览

热门推荐

通过挑战的用户

查看代码

相关试题

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

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号