Exercise DS

#include <iostream>
using namespace std;

typedef struct Node
{
    Node *next;
    int data;
}Node, *List;

typedef struct DNode
{
    DNode *prior;
    DNode *next;
    int data;
}DNode, *DList;

void creatList(List &l)
{
    l = new Node;
    Node *p = l;
    int data;
    while ((cin>>data) && data != -1)
    {
        Node *q= new Node;
        q ->data = data;
        p ->next = q;
        p = p->next;
    }
    p ->next = nullptr;
}

void printList(List &l)
{
    Node *p = l->next;
    while (p)
    {
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

void reversePrint(List &l)
{
    Node *p =l;
    if (p->next != nullptr)
        reversePrint(p->next);
    cout<<p->data<<" ";
}

void removeMin(List &l)
{
    Node *p = l->next;
    int min = p->data;
    Node *flag = nullptr;
    while (p)
    {
        if (p->next ==nullptr) break ;
        if (p->next->data < min)
        {
            min = p->next->data;
            flag = p;
        }
        p = p->next;
    }

    Node *q = flag ->next;
    flag ->next = q->next;
    free(q);
}

void reverseList (List &l)
{
    Node *p = l->next;
    l->next = nullptr;
    Node *q;
    while (p)
    {
        q = p->next;
        p->next = l->next;
        l->next = p;
        p = q;
    }
}

void selectSort(List &l)
{
    Node * p = l->next;
    while (p)
    {
        Node *q = p->next;
        Node *flag = p;
        while (q)
        {
            if (q->data < flag->data)
                flag = q;
            q = q->next;
        }
        swap (p->data,flag->data);
        p = p->next;
    }
}

void removeMM(List &l)
{
    Node* p = l->next;
    Node* min = p;
    Node* max = p;
    while (p)
    {
        if (p->data > max->data)
            max = p;
        if (p->data < min->data)
            min = p;
        p = p->next;
    }

    Node* q = l;

    while (q)
    {
        Node * s = q->next;
        if ((s->data>min->data) && (s->data<max->data ))
        {
            q ->next = s->next;
            free(s);
        }
        q = q->next;
    }
}

int length(List &l)
{
    int i = 0;
    if (!l || !l->next)
        return 0;
    Node *p = l->next;
    while (p)
    {
        i++;
        p = p->next;
    }
    return i;
}

Node* Search_1st_common(List &l1,List &l2)
{
    int len1 = length(l1);
    int len2 = length(l2);

    List longList = (len1>len2)?l1:l2;
    List shortList = (len1<len2)?l1:l2;
    int dist = (len1>len2)?(len1-len2):(len2-len1);

    while (dist--) longList = longList->next;

    while (longList)
    {
        if (longList->data == shortList->data)
            return longList;
        else
        {
            longList = longList->next;
            shortList = shortList->next;
        }
    }
    return nullptr;
}

void freeALL(List &l)
{
    while (l->next)
    {
        Node* pre = l;
        Node*p = pre->next;

        while (p->next)
        {
            if (p->next->data<pre->next->data)
                pre = p;
            p = p->next;
        }
        printf("%d ",pre->next->data);
        Node *u = pre->next;
        pre->next =u->next;
        free (u);
    }
    free(l);
}

void divideList(List &l,List &r1)
{
    Node *p = l->next;
    r1 = new Node;
    Node *r = r1;
    while (p->next)
    {
        Node* s = new Node;
        s->data = p->next->data;
        Node* t = p->next;
        p ->next = t->next;
        r->next = s;
        r = r-> next;
        free(t);
        p = p->next;
    }
    r->next = nullptr;
}

void removeCF(List &l)
{
    Node *p = l->next;
    while (p->next)
    {
        Node *q = p->next;
        if (q->data == p->data)
        {
            p->next = q->next;
            free(q);
        }
        else
            p = p->next;
    }
}

void MergeList(List &l1,List &l2)
{
    Node *p = l1->next;
    Node *q = l2->next;
    l1->next = nullptr;
    Node *s;
    while (p && q)
    {
        if (p->data<q->data)
        {
            s = p->next;
            p->next = l1->next;
            l1->next = p;
            p = s;
        }
        else {
            s = q->next;
            q->next = l1->next;
            l1->next = q;
            q = s;
        }
    }

    if (p) q = p;

    while (q)
    {
        s = q->next;
        q->next = l1->next;
        l1->next = q;
        q = s;
    }
}

void inserthead(List &l)
{
    l = new Node;
    l ->next =nullptr;

    Node *s;
    int data;
    while (cin>>data && data != -1)
    {
        s = new Node;
        s ->data = data;
        s ->next = l->next;
        l ->next = s;
    }
}

List getCommon(List &l1,List &l2)
{
    List l3 = new Node;
    Node *p = l1->next;
    Node *q = l2->next;
    Node *t = l3;
    while (p && q)
    {
        if (p->data == q->data)
        {
            Node* s = new Node;
            s->data = p->data;
            t ->next = s;
            t = t->next;
            p = p->next;
            q = q->next;
        }
        else if (p->data > q->data)
            q = q->next;
        else p = p->next;
    }
    t->next = nullptr;
    return l3;
}

void UnionList(List &l1,List &l2)
{
    Node *p = l1->next;
    Node *q = l2->next;
    Node *s = l1, *u;

    while (p && q)
    {
        if (p->data == q->data)
        {
            s->next = p;
            s = p;
            u = q;
            q = q->next;
            p = p->next;
            free (u);
        }
        else if (p->data > q->data)
        {
            u = q;
            q = q->next;
            free (u);
        }
        else { u = p ; p = p->next ; free (u);}
    }
    while (p) { u = p; p = p->next; free (u);}
    while (q) { u = q; q = q->next; free (u);}
    s ->next = nullptr;
    free (l2);
}

bool isSubseq(List &l1,List &l2)
{
    Node *p = l1->next;
    Node *q = l2->next;

    Node *s = p;
    while (p && q)
    {
        if (p->data == q->data)
        {
            p = p->next;
            q = q->next;
        }
        else
        {
            s = s->next;
            p = s;
            q = l2->next;
        }
    }
    if (!q) return true;
    else return false;
}

void crtDbCirList(DList &l)
{
    l = new DNode;
    DNode*p = l;

    int data;
    while (cin>>data && data != -1)
    {
        DNode* q = new DNode;
        q ->data = data;
        p ->next = q;
        q ->prior = p;
        p = p->next;
    }
    p ->next = l->next;
    l ->next ->prior = p;
}

bool isSymmetry(DList &dl)
{
    DNode *p = dl->next;
    DNode *q = dl->next->prior;

    while ( p != q && (p->next != q->prior))
    {
        //printf ("fuck");
        if (p->data == q->data)
        {
            p = p->next;
            q = q->prior;
        }
        else return false;
    }

    return true;
}

int main()
{
    /*List s;
    List s2;
    creatList(s);
    creatList(s2);
     */
    //printList(s);
    //printList(s2);
    //reversePrint(s);
    //removeMin(s);
    //reverseList(s);
    //selectSort(s);
    //printList(s);
    //cout<<length(s)<<endl<<length(s2)<<endl;
    //cout<<Search_1st_common(s, s2)->data<<endl;

    /*List s2;
    divideList(s, s2);
    printList(s);
    printList(s2);
     */

    //removeCF(s);
    //MergeList(s,s2);
    //List s3 = getCommon(s, s2);
    //printList(s3);

    //UnionList(s, s2);
    //printList(s);
    //cout<<isSubseq(s, s2)<<endl;

    DList dl;
    crtDbCirList(dl);
    DNode *q = dl->next;
    DNode *f = dl->next->prior;

    cout<<q->data<<" "<<f->prior->data<<endl;

    if (isSymmetry(dl)) cout<<"success"<<endl;
    else cout<<"fail"<<endl;

    return 0;
}

Exercise DS,布布扣,bubuko.com

时间: 2024-11-03 21:51:22

Exercise DS的相关文章

MIT 6.828 JOS学习笔记5. Exercise 1.3

Exercise 1.3 设置一个断点在地址0x7c00处,这是boot sector被加载的位置.然后让程序继续运行直到这个断点.跟踪/boot/boot.S文件的每一条指令,同时使用boot.S文件和系统为你反汇编出来的文件obj/boot/boot.asm.你也可以使用GDB的x/i指令来获取去任意一个机器指令的反汇编指令,把源文件boot.S文件和boot.asm文件以及在GDB反汇编出来的指令进行比较. 追踪到bootmain函数中,而且还要具体追踪到readsect()子函数里面.找

Windows server 2008 R2 AD DS搭建(额外DNS)

使用额外的DNS服务器搭建AD DS服务器,AD DS服务器本身不是DNS服务器. 先决条件: 1台DNS服务器,1台AD DS服务器: DNS服务器开启动态更新: 部署参考步骤如下: 1.DNS服务器信息检查 2.AD DS服务器信息检查 3.在DNS服务器上面运行dnsmgmt.msc,确定 4.右击"正向查找区域",选择"新建区域" 5.选择下一步 6.选择"主要区域" 7.输入域名"contoso.local",下一步

在Windows7上安装和使用AD DS管理工具

为什么要安装AD DS管理工具 要管理活动目录,默认只有在域控制器下才可以,管理员对活动目录的管理和维护又比较频繁,因此需要经常出入机房才能完成管理任务 用远程桌面也可以进行域管理,但有一定的安全隐患,还会产生较大的网络流量,占用宝贵的带宽资源 AD DS是微软公司基于Windows7系统推出的远程服务管理工具,默认情况下已经设置好了安全措施,可以管理活动目录上的特定功能 下载地址:Download Windows 7 Service Pack 1 (SP1) 远程服务器管理工具 http://

DS.DELMIA.VMAP.V5-6R2017.SP2.Win32

Tracrite.Software.Optimum.Control.Pro.v4.00.08.0102 Agisoft.PhotoScan.Professional.v1.3.2.4164 x64 Altair.HyperWorks.2017.1.Suite.Win64 DS.DELMIA.VMAP.V5-6R2017.SP2.Win32 exida.exSILentia.2014.v2.4.0.25 IMOLD.V13.SP4.2.for.SolidWorks2011-2017 maxmess

为什么要安装AD DS管理工具

要管理活动目录,默认只有在域控制器下才可以,管理员对活动目录的管理和维护又比较频繁,因此需要经常出入机房才能完成管理任务 用远程桌面也可以进行域管理,但有一定的安全隐患,还会产生较大的网络流量,占用宝贵的带宽资源 AD DS是微软公司基于Windows7系统推出的远程服务管理工具,默认情况下已经设置好了安全措施,可以管理活动目录上的特定功能 下载地址:Download Windows 7 Service Pack 1 (SP1) 远程服务器管理工具 http://www.microsoft.co

Exercise: Maps (单词统计)

A Tour of Go Exercise: Maps https://tour.golang.org/moretypes/23 WordCount (单词统计) 是一个很经典的小程序了,在很多编程入门教程中都会出现. 这道题比较简单,但也有一些知识点值得一提. 上面这个答案我是参考了网上别人写的.但在参考别人之前我也自己解题了,其中,唯一不同之处是这一句: m[word]++ 我本来写的是: _, ok := m[word] if ok { m[word]++ } else { m[word]

Exercise: Slices (画图)

A Tour of Go Exercise: Slices https://tour.golang.org/moretypes/18 这道题目,提供了一个画图函数 (pic.Show), 可以生成图片. 这个函数,即 pic.Show(f func(int, int) [][]uint8), 可见,它接受一个函数做参数,题目要求的正是编写这个参数.答案如下: 这里面,依赖一个 package, 即 "golang.org/x/tour/pic" 我上 https://github.co

Stanford coursera Andrew Ng 机器学习课程编程作业(Exercise 2)及总结

Exercise 1:Linear Regression---实现一个线性回归 关于如何实现一个线性回归,请参考:http://www.cnblogs.com/hapjin/p/6079012.html Exercise 2:Logistic Regression---实现一个逻辑回归 问题描述:用逻辑回归根据学生的考试成绩来判断该学生是否可以入学. 这里的训练数据(training instance)是学生的两次考试成绩,以及TA是否能够入学的决定(y=0表示成绩不合格,不予录取:y=1表示录

Azure上A/D系列虚拟机到DS系列迁移(1)

有一些用户在刚开始的时候创建了A7,D14等虚拟机来跑一些IO要求比较高的应用,比如Oracle数据库,MySQL数据库,等到用户量上来之后,性能不够,需要升级数据磁盘到SSD固态硬盘,但是问题是: Azure的固态硬盘SSD磁盘属于高级存储Premium Storage A系列,D系列的虚拟机无法使用高级存储作为数据磁盘 只有DS,DSv2,GS系列的虚拟机才可以使用SSD作为数据磁盘 A系列,D系列虚拟机无法直接升级为DS/GS系列 GS系列暂时在中国没有上线 那么在这种情况下,除了创建高级