[已解决]xdm,看看这个为什么报错了

hehexixi

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。

输入格式:
输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。

输出格式:
在一行中输出合并后新的非降序链表，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
typedef int LinkList;
typedef struct Node
{
        ElemType data;
        struct Node* next;
}Node;
typedef struct Node* LinkList;

void CreatListHead(LinkList* L)
{
        LinkList p;
        int i;
        int l;
        *L = (LinkList)malloc(sizeof(Node));
        (*L)->next = NULL;
        scanf("%d", &l);
        while (l>0)
        {
                p = (LinkList)malloc(sizeof(Node));
                
                p->data = l;
                p->next = (*L) ->next;
                (*L)->next = p;
                scanf("%d", &l);
        }
}
Status ListInsert(LinkList* L, int i, ElemType e)
{
        int j;
        LinkList p, s;
        p = *L;
        j = 1;
        while (p&&j<i)
        {
                p = p->next;
                ++j;
        }
        if (!p || j > i)
                return ERROR;
        s = (LinkList)malloc(sizeof(Node));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return OK;
}
void pri(LinkList *L)
{
        LinkList p, q;
        p = (LinkList)malloc(sizeof(Node));
        q = (LinkList)malloc(sizeof(Node));
        p = *L;
        
        if (L)
        {
                q->next;
                while (p->next&&q->next)
                {
                        printf("%d", p->data);
                        p = q;
                        q = q->next;
                }
                
        }
        else
        {
                printf("NULL\n");
        }
}

void merge(LinkList la, LinkList lb, LinkList lc)
{
        la = la->next;
        lb = lb->next;
        while (la&&lb)
        {
                if (la->data > lb->data)
                {
                        lc->next = lb;
                        lb = lb->next;
                }
                else
                {
                        lc->next = la;
                        la = la->next;
                }
                lc = lc->next;
        }
        if (la)
        {
                lc->next = la;
        }
        if (lb)
        {
                lc->next = lb;
        }
}
int main()
{
        LinkList la, lb, lc;
        CreatListHead(la);
        CreatListHead(lb);
        CreatListHead(lc);
        merge(la, lb, lc);
        pri(lc);
        return 0;
}

找半天问题了

最佳答案

月排行榜 / 总排行榜

人造人

2021-11-5 15:26:25

跳转到最佳答案楼层

人造人

hehexixi

人造人 发表于 2021-11-5 16:38

hxd,应该怎么改啊，救救孩子吧

monkey-D

先不说逻辑上的错误，代码本身有问题，建议还是对着书本或者网站的样例比对一下。

人造人

hehexixi 发表于 2021-11-5 17:13
hxd,应该怎么改啊，救救孩子吧

你这代码写的真的没法改
把你这个代码改能用了，基本上这个代码就看不出是你写的了，需要的话，我给你重写一个
简单来说就是，改这个代码不如重写一个

人造人

等一等，我给你重写一个

hehexixi

monkey-D 发表于 2021-11-5 17:43
先不说逻辑上的错误，代码本身有问题，建议还是对着书本或者网站的样例比对一下。

就按照甲鱼老师数据结构打的

人造人

hehexixi 发表于 2021-11-5 18:43
就按照甲鱼老师数据结构打的

人造人

1. 不要把所有的代码都写到一个文件中，这样不方便修改，不方便阅读
2. 申请了内存要释放，你为什么不写释放内存的代码？
释放内存，这么重要的操作你居然完全忽略？
3. 你的代码还有很多其他问题，我没有一个一个去看

list.h

#ifndef _LIST_H_
#define _LIST_H_

#include <stddef.h>
#include <stdbool.h>

struct list_node_tag {
    void *data; size_t size;
    struct list_node_tag *next;
};

typedef struct {
    struct list_node_tag *head;
    size_t size;
} list_t;

list_t *list_init(void);
void list_deinit(list_t *list);
bool list_clean(list_t *list);
bool list_insert(list_t *list, size_t index, void *data, size_t size);
bool list_delete(list_t *list, size_t index);
bool list_get(const list_t *list, size_t index, void *data, size_t size);
bool list_append(list_t *list, void *data, size_t size);
size_t list_size(const list_t *list);
bool list_empty(const list_t *list);

#endif

list.c

#include "list.h"
#include <stdlib.h>
#include <memory.h>

list_t *list_init(void) {
    list_t *list = malloc(sizeof(*list));
    if(!list) return NULL;
    list->head = NULL;
    list->size = 0;
    return list;
}

void list_deinit(list_t *list) {
    if(!list) return;
    list_clean(list);
    free(list);
}

bool list_clean(list_t *list) {
    if(!list) return false;
    while(!list_empty(list)) list_delete(list, 0);
    return true;
}

bool list_insert(list_t *list, size_t index, void *data, size_t size) {
    if(!list) return false;
    if(list_size(list) < index) return false;
    if(!data) return false;
    struct list_node_tag **current = &list->head;
    while(index--) current = &(*current)->next;
    struct list_node_tag *node = malloc(sizeof(*node));
    if(!node) return false;
    node->data = malloc(size);
    if(!node->data) {free(node); return false;}
    memcpy(node->data, data, size);
    node->size = size;
    node->next = *current;
    *current = node;
    ++list->size;
    return true;
}

bool list_delete(list_t *list, size_t index) {
    if(!list) return false;
    if(list_size(list) <= index) return false;
    struct list_node_tag **current = &list->head;
    while(index--) current = &(*current)->next;
    struct list_node_tag *temp = *current;
    *current = temp->next;
    free(temp->data); free(temp);
    --list->size;
    return true;
}

bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    if(!list) return false;
    if(list_size(list) <= index) return false;
    if(!data) return false;
    struct list_node_tag *const *current = &list->head;
    while(index--) current = &(*current)->next;
    struct list_node_tag *temp = *current;
    if(temp->size > size) return false;
    memcpy(data, temp->data, size);
    return true;
}

bool list_append(list_t *list, void *data, size_t size) {
    if(!list) return false;
    return list_insert(list, list_size(list), data, size);
}

size_t list_size(const list_t *list) {
    if(!list) return 0;
    return list->size;
}

bool list_empty(const list_t *list) {
    if(!list) return 0;
    return list_size(list) == 0;
}

main.c

#include "list.h"
#include <stdio.h>

void read_number(list_t *list) {
    while(1) {
        size_t n; scanf("%lu", &n);
        if(n == 0) break;
        list_append(list, &n, sizeof(n));
    }
}

list_t *list_merge(const list_t *a, const list_t *b) {
    size_t i = 0, j = 0;
    list_t *list = list_init();
    while(i < list_size(a) && j < list_size(b)) {
        size_t m, n;
        list_get(a, i, &m, sizeof(m));
        list_get(b, j, &n, sizeof(n));
        if(m < n) {
            list_append(list, &m, sizeof(m));
            ++i;
        } else {
            list_append(list, &n, sizeof(n));
            ++j;
        }
    }
    while(i < list_size(a)) {
        size_t m;
        list_get(a, i, &m, sizeof(m));
        list_append(list, &m, sizeof(m));
        ++i;
    }
    while(j < list_size(b)) {
        size_t n;
        list_get(b, j, &n, sizeof(n));
        list_append(list, &n, sizeof(n));
        ++j;
    }
    return list;
}

void list_output(const list_t *list) {
    const char *sep = "";
    for(size_t i = 0; i < list_size(list); ++i) {
        size_t temp; list_get(list, i, &temp, sizeof(temp));
        printf("%s%lu", sep, temp); sep = " ";
    }
    printf("\n");
}

int main(void) {
    list_t *s1 = list_init();
    list_t *s2 = list_init();
    read_number(s1);
    read_number(s2);
    list_t *s3 = list_merge(s1, s2);
    list_output(s3);
    list_deinit(s3);
    list_deinit(s2);
    list_deinit(s1);
    return 0;
}

hehexixi

人造人 发表于 2021-11-5 20:58
1. 不要把所有的代码都写到一个文件中，这样不方便修改，不方便阅读
2. 申请了内存要释放，你为什么不写释 ...

谢了大兄弟