队列链表实现以及有序表的合并

#include<iostream>
#include<algorithm>
using namespace std;
typedef struct Node{
    int data;
    Node *next;
}LNode, *LinkList;
void Creat(LinkList &L){
    L = new Node;
    L->next = NULL;
    cout << "你已经成功创建了一个队列" << endl;
}
void Insert(LinkList &L, int n){
    cout << "请输入" << n << "个需要插入的元素" << endl;
    LNode *p, *cur;
    cur = L;
    for(int i = 0; i < n; i++){
        p = new LNode;
        cin >> p->data;
        p->next = NULL;
        cur->next = p;
        cur = p;
    }
    cout << "创建结束" << endl;
}
void Pop(LinkList &L){
    if(L->next == NULL){
        cout << "弹出错误" << endl;
        return;
    }
    LNode *p, *q;
    p = L->next;
    q = p->next;
    L->next = q;
    cout << "队顶元素是 " <<  p->data << endl;
    delete p;
}
int main(){
    LinkList L;
    Creat(L);
    cout << "输入插入长度" << endl;
    int n;
    cin >> n;
    Insert(L, n);
    while(L->next){
        Pop(L);
    }
    return 0;
}
#include<iostream>
using namespace std;

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

void InitList_L(LNode* &L)                                //创建单链表
{
    L=new LNode;
    L->next=NULL;
}

void input(LinkList &L,int n)                                //依次往单链表L里输入数据
{
    int i;
    LinkList p,r;
    r=L;
    cout<<"请输入该表的元素(按非递减的顺序):";
    for(i=0;i<n;i++)
    {
        p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}

void output(LinkList L)                                        //依次输出单链表里的每个元素
{
    int i=0;
    LNode *p;
    p=L->next;
    while(p)
    {
        if(i)
            cout<<",";
        cout<<p->data;
        p=p->next;
        i=1;
    }
}

void MergeList_L(LinkList &LA,LinkList &LB,LinkList &LC)        //算法2.16 链式有序表的合并
{
    //已知单链表LA和LB的元素按值非递减排列
    //归并LA和LB得到新的单链表LC,LC的元素也按值非递减排列

    //以下填空缺部分
    LNode *p, *q, *cur, *temp;
    p = LA->next;
    q = LB->next;
    cur = LC;
    while(p && q){
        if(p->data <= q->data){
            temp = new LNode;
            temp->data = p->data;
            temp->next = NULL;
            cur->next = temp;
            cur = temp;
            p = p->next;
        }
        else{
            temp = new LNode;
            temp->data = q->data;
            temp->next = NULL;
            cur->next = temp;
            cur = temp;
            q = q->next;
        }
    }
    if(p){
        cur->next = p;
    }
    if(q){
        cur->next = q;
    }
}    //MergeList_L()

int main()
{
    LinkList La,Lb,Lc;
    int num_a,num_b;

    cout<<"请输入非递减单链表a的个数n:";
    cin>>num_a;
    InitList_L(La);                                                    //La表的创建
    input(La,num_a);                                                //依次往单链表La里输入数据

    cout<<"请输入非递减单链表b的个数n:";
    cin>>num_b;
    InitList_L(Lb);                                                    //Lb表的创建
    input(Lb,num_b);                                                //依次往单链表La里输入数据

    InitList_L(Lc);
    MergeList_L(La,Lb,Lc);                                            //将单链表La和Lb进行合并

    cout<<"非递减单链表a,b合并后的非递减单链表c为:\n";            //输出合并后的单链表Lc
    output(Lc);
    cout<<endl;
    return 0;
}
时间: 2024-11-04 18:57:25

队列链表实现以及有序表的合并的相关文章

[BZOJ 1483][HNOI 2009]梦幻补丁(有序表启发式合并)

题目:http://www.lydsy.com:808/JudgeOnline/problem.php?id=1483 分析: 先将不同的颜色的出现位置从小到大用几条链表串起来,然后统计一下答案 对于每次修改,修改一下答案即可,修改之后需要将两个颜色的链表合并就行了,但感觉似乎会TLE? 以下摘录与Hzwer的blog: 1:将两个队列合并,有若干队列,总长度为n,直接合并,最坏O(N), 2:启发式合并呢? 每次我们把短的合并到长的上面去,O(短的长度) 咋看之下没有多大区别, 下面让我们看看

有序表的实现

所谓的有序表表,顾名思意啊,有序表应该就是数据是有一定顺序排列的,准确定义为:线性表中全部元素以递增或递减方式排列,并规定有序表中不存在不存在元素值同样的元素. 他是逻辑上的概念,不是物理上的. 逻辑结构类型有,线性结构,树形结构,图形结构,表示每一个节点之间的组织结构.物理上的结构有顺序存储结构,链式存储结构, 索引存储和哈希散列,表示逻辑上的数据结构以什么样的方式存储在存储设备上. 顺序表跟单链表都逻辑上都属于线性结构,可是顺序表是顺序存储在内存上,单链表是链式存储在内存上.而有序表则是一种

数据结构例程——合并有序表

本文针对数据结构基础系列网络课程(2):线性表中第15课时有序表. 问题:有两个有序表LA和LB,将它们合并成一个有序表LC.要求不破坏原有表LA和LB 算法思想: 解法1:用顺序表实现(支持的算法库,及list.h文件,请点击链接-) #include "list.h" void UnionList(SqList *LA,SqList *LB,SqList *&LC) { int i=0,j=0,k=0; //i.j.k分别作为LA.LB.LC的下标 LC=(SqList *

算法学习之查找算法:静态查找表(2)有序表查找

如果静态查找表是一个有序表,则可以使用折半查找. 折半查找的过程是:先确定待查记录所在的范围(区间),然后逐步缩小范围直到找到或找不到该记录为止.折半查找过程是以处于区间中间位置记录的关键字和给定值比较,若相等,则查找成功,若不等,则缩小范围,直至新的区间中间位置记录的关键字等于给定值或者查找区间的大小小于零时(表明查找不成功)为止. 关键字key与表中某一元素array[i]比较,有3种情况: 1.key==array[i],查找成功 2.key > array[i],待查找元素可能的范围是a

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

数据结构实验之链表四:有序链表的归并 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 5

基础数据结构-线性表-顺序表的合并操作

因为最近笔记本B面裂了准备去修,复杂些的会优先加上注释,所以在家先把代码和题目贴上来以后补文字,有疑问可以在下面留言. 顺序表的合并操作 题目描述建立顺序表的类,属性包括:数组.实际长度.最大长度(设定为1000) 已知两个递增序列,把两个序列的数据合并到顺序表中,并使得顺序表的数据递增有序输入第1行先输入n表示有n个数据,接着输入n个数据,表示第1个序列,要求数据递增互不等 第2行先输入m表示有m个数据,接着输入m个数据,表示第2个序列,要求数据递增互不等输出顺序表内容包括顺序表的实际长度和数

非递减顺序表的合并

//顺序表的合并 //输入元素函数 put //输出元素函数 output //合并 Merge #include<stdio.h> #include<stdlib.h> #include<algorithm> using namespace std; #define LIST_INIT_SIZE 80 #define LISTINCREMENT 10 typedef struct { int *elem; int length; //有效长度 int size; //

数据结构之顺序表的合并

写一个程序完成以下功能: (1)  一条记录有学号和成绩两个数据项,依次输入数据(学号,成绩): (5,60),(6,80),(7,76),(8,50),建立一个顺序表,并写一个插入函数,把以上数据写到主函数中依次调用插入函数.要求:先输入的数据排在前面,不要按学号或成绩从大到小排序. (2)  依次输出表中所有数据. (3)  写一个函数对表中所有数据按照成绩从大到小进行排序. (4)  再次输出所有数据. (5)  建立另外一个顺序表,依次输入数据:(10,70),(20,85),(30,7

顺序表查找和有序表查找

查找里面顺比表查找和有序表查找(包括二分查找,插值查找,斐波那契查找)比较简单,直接贴代码,代码里面有详细注释. 1 #include <iostream> 2 using namespace std; 3 4 //顺序表查找(线性查找.静态表查找) 时间复杂度为O(n) 5 int Seq_Search(int *s,int n,int key) 6 { 7 s[0] = key; //设置了一个哨兵,避免了每次比较一次过后都要判断查找位置是否越界 8 int i = n; 9 while