数据结构之 线性表---有序链表的归并

数据结构实验之链表四:有序链表的归并

Time Limit: 1000MS Memory limit: 65536K

题目描述

分别输入两个有序的整数序列(分别包含M和N个数据),建立两个有序的单链表,将这两个有序单链表合并成为一个大的有序单链表,并依次输出合并后的单链表数据。

输入

第一行输入M与N的值;
第二行依次输入M个有序的整数;
第三行依次输入N个有序的整数。

输出

输出合并后的单链表所包含的M+N个有序的整数。

示例输入

6 5
1 23 26 45 66 99
14 21 28 50 100

示例输出

1 14 21 23 26 28 45 50 66 99 100

提示

不得使用数组!

#include <iostream>
#include <string>
#include <stdio.h>
#include <string.h>
#include <queue>
#define INF 99999999

using namespace std;

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

struct node *creat(int n)
{
    int i;
    node *head, *p, *tail;
    head = new node;
    head->next = NULL;
    tail=head;

    for(i=0; i<n; i++)
    {
        p=new node;
        cin>>p->data;
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    return head;
}

struct node *merge(node *h1, node *h2)
{
    struct node *p1, *p2, *tail;
    p1=h1->next;
    p2=h2->next;
    delete h2;  //释放h2
    tail=h1;
    while(p1 && p2)
    {
        if(p1->data < p2->data)//链上data值小的
        {
            tail->next=p1;
            tail=p1;
            p1=p1->next;
        }
        else
        {
            tail->next=p2;
            tail=p2;
            p2=p2->next;
        }
    }
    if(p1)
    {
        tail->next=p1;
    }
    else
    {
        tail->next=p2;
    }
    return h1;
}

int main()
{
    int n, m;

    cin>>n>>m;
    int i;

    node *h1, *h2, *h3, *w;
    h1=creat(n);
    h2=creat(m);

    h3=merge(h1, h2);
    w=h3->next;

    for(i=0; i<n+m; i++)
    {
        if(i==0)
        {
            cout<<w->data;
        }
        else
        {
            cout<<" "<<w->data;
        }
        w=w->next;
    }
    cout<<endl;

    return 0;
}

数组实现:

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

int a[100];
int b[100];
int c[200], e=0;

int main()
{
    int i, j;
    int n, m;

    scanf("%d %d", &n, &m );
    for(i=0; i<n; i++)
    {
        scanf("%d", &a[i] );
    }
    for(j=0; j<m; j++)
    {
        scanf("%d", &b[j] );
    }

    i = 0;
    j = 0;

    while(i<n && j<m )
    {
        if(a[i] <= b[j] )
        {
            c[e++] = a[i] ;
            i++;
        }
        else
        {
            c[e++] = b[j];
            j++;
        }
    }
    if(i==n && j<m)
    {
        while(j<m)
        {
            c[e++] = b[j];
            j++;
        }
    }
    else if(j==m && i<n)
    {
        while(i<n)
        {
            c[e++] = a[i] ;
            i++;
        }
    }

    for(i=0; i<e; i++)
    {
        if(i==0)
            printf("%d", c[0] );
        else
            printf(" %d", c[i] );
    }
    printf("\n");
    return 0;
}
时间: 2025-01-18 17:21:55

数据结构之 线性表---有序链表的归并的相关文章

数据结构之 线性表---有序链表的建立

mxjj130304杨少鹏(13110581086)        注销 数据结构实验之链表六:有序链表的建立 数据结构实验之链表六:有序链表的建立 Time Limit: 1000MS    Memory limit: 65536K 题目描述 输入N个无序的整数,建立一个有序链表,链表中的结点按照数值非降序排列,输出该有序链表. 输入 第一行输入整数个数N: 第二行输入N个无序的整数. 输出 依次输出有序链表的结点值. 示例输入 6 33 6 22 9 44 5 示例输出 5 6 9 22 3

数据结构之线性表(链表)

链表 1.链表的定义:线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是 连续的,也可以是不连续的).因此,为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系,对数据元素 ai来说,除了存储其本身的信息之外,还需存储一个指示其直接后继的信息(即直接后继的存储位置).这两部分信息组 成数据元素ai的存储映像,称为结点.它包括两个域,其中存储数据元素信息的域称为数据域:存储直接后继存储位置的 域称为指针域.指针域中存储的信息称做指针或链.n个结点

数据结构之 线性表---单链表操作A (删除链表中的指定元素)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

数据结构之 线性表---单链表的操作B(先逆序+再删除重复元素)

数据结构上机测试2-2:单链表操作B Time Limit: 1000MS Memory limit: 65536K 题目描述 按照数据输入的相反顺序(逆位序)建立一个单链表,并将单链表中重复的元素删除(值相同的元素只保留最后输入的一个). 输入 第一行输入元素个数n: 第二行输入n个整数. 输出 第一行输出初始链表元素个数: 第二行输出按照逆位序所建立的初始链表: 第三行输出删除重复元素后的单链表元素个数: 第四行输出删除重复元素后的单链表. 示例输入 10 21 30 14 55 32 63

数据结构之 线性表---单链表的应用(重复元素删除)

数据结构上机测试1:顺序表的应用 Time Limit: 1000MS Memory limit: 65536K 题目描述 在长度为n(n<1000)的顺序表中可能存在着一些值相同的“多余”数据元素(类型为整型),编写一个程序将“多余”的数据元素从顺序表中删除,使该表由一个“非纯表”(值相同的元素在表中可能有多个)变成一个“纯表”(值相同的元素在表中只能有一个). 输入 第一行输入表的长度n: 第二行依次输入顺序表初始存放的n个元素值. 输出 第一行输出完成多余元素删除以后顺序表的元素个数: 第

数据结构之 线性表---单链表的拆分

数据结构实验之链表五:单链表的拆分 Time Limit: 1000MS Memory limit: 65536K 题目描述 输入N个整数顺序建立一个单链表,将该单链表拆分成两个子链表,第一个子链表存放了所有的偶数,第二个子链表存放了所有的奇数.两个子链表中数据的相对次序与原链表一致. 输入 第一行输入整数N;: 第二行依次输入N个整数. 输出 第一行分别输出偶数链表与奇数链表的元素个数: 第二行依次输出偶数子链表的所有数据: 第三行依次输出奇数子链表的所有数据. 示例输入 10 1 3 22

数据结构_线性表_链表实现

之前已经完全忘了指针怎么用了.复习了一下,目前只写了一点点. #include<iostream> #include<cstdio> #include<malloc.h> using namespace std; struct Node { int e; double c; Node* next; }; struct Head { int cnt; Node* elem; }; Head* inilHead() { Head *head; head=(Head*)mal

[考研系列之数据结构]线性表之链表

1.链表分类 通过线性表概述,我们知道了链表这样一种数据结构,它又分成三类,分别是 单向链表 循环链表 双向链表 单向链表 单向链表的指针域只有一个指向下一个节点的指针,需要注意几点: 1.头指针--指向第一个节点 2.最后一个结点的指针指向NULL 3.头结点--在链表的第一个结点之前附设一个结点,它的数据域为空 所以,我们看到:  单向链表为空的<=>链表有且只有一个头结点<=>头结点的指针指向NULL 循环链表 循环链表和单向链表最大的不同就是:最后一个结点的指针不再指向NU

[笔记]python数据结构之线性表:linkedlist链表,stack栈,queue队列

python数据结构之线性表 python内置了很多高级数据结构,list,dict,tuple,string,set等,在使用的时候十分舒心.但是,如果从一个初学者的角度利用python学习数据结构时,这些高级的数据结构可能给我们以迷惑. 比如,使用list实现queue的时候,入队操作append()时间复杂度可以认为是O(1),但是,出队操作pop(0)的时间复杂度就是O(n). 如果是想利用python学学数据结构的话,我觉得还是自己实现一遍基本的数据结构为好. 1.链表 在这里,我想使