• 对链表的操作(数据结构线性表算法设计练习)


    /*1.有一个单链表(不同结点的数据域值可能相同),其头指针为head,编写一个函数计算数据域为x的结点个数*/
    #include <iostream>
    #include <cstdio>
    using namespace std;
    
    struct node{
      int data;
      struct node *next;
      };
    struct node *head;
    
     /*计算数据域为x的结点个数*/
    int List_count (int x){
                int count=0;
                node*p;
                p=head;
                while(p){
                    if (p->data==x)
                    {
                        count++;
                    }
                    p=p->next;
                }
                return count;
            }
    
    int main()
    {
       struct node *p,*q,*t;
        int i,n,a;
        printf("输入data个数
    ");
        scanf("%d",&n);
        head = NULL;
        printf("输入data
    ");
        for(i=1;i<=n;i++){
            scanf("%d",&a);
            p=(struct node *)new(struct node);
            p->data=a;
            p->next=NULL;
            if(head==NULL)
                head=p;
            else
                q->next=p;
    
            q=p;
        }
    
        /*打印这个链表*/
        t= head;
        printf("你输入的data为: 
    ");
        while(t!=NULL){
            printf("%d ",t->data);
            t=t->next;
              }
            printf("
    ");
            printf("输入要计数的数据域x
    ");
            int x;
            scanf("%d",&x);
            printf("数据域为%d的节点个数为%d",x,List_count(x));
    
        return 0;
    }
    
    /*2.有一个有序单链表(从小到大排序),表头指针为head,编写一个函数向该单链表中插入一个元素为x的结点,使插入后该链表仍然有序。*/
    #include <iostream>
    #include <cstdio>
    using namespace std;
    
    struct node{
      int data;
      struct node *next;
      };
    
    int main()
    {
       struct node *head,*p,*q,*t;
        int i,n,a;
        scanf("%d",&n);
        head = NULL;
        for(i=1;i<=n;i++){
            scanf("%d",&a);
            p=(struct node *)new(struct node);
            p->data=a;
            p->next=NULL;
            if(head==NULL)
                head=p;
            else
                q->next=p;
    
            q=p;
        }
        scanf("%d",&a);
        t= head;
        while(t!=NULL){
            if(t->next==NULL||t->next->data > a){
                p=(struct node *)new(struct node);
                p->data=a;
                p->next=t->next;
                t->next=p;
                break;
            }
                    t=t->next;
        }
        t=head;
        while(t!=NULL){
            printf("%d ",t->data);
            t=t->next;
        }
    
        return 0;
    }
    
    /*3.编写一个函数将一个头指针为a的单链表A分解成两个单链表A和B,其头指针分别为a和b,使得A
    链表中含有原链表A中序号为奇数的元素,而B链表中含有原链表A中序号为偶数的元素,且保持原来的相对顺序。*/
    #include <cstdio>
    #include <iostream>
    using namespace std;
    struct node
    {
        int data;
        node * next;
    }*hda,*hdb;
    
    void text()
    {
        node *tmp=hda;
        for(int i=1;i<=20;i++)
        {
            tmp->next=(node*)new(node);
            tmp=tmp->next;
            tmp->data=i;
            printf("%d ",tmp->data);
        }
        tmp->next=NULL;
        printf("
    ");
    }
    void print()
    {
        node *ta,*tb;
        ta=hda;
        ta=ta->next;
    
        while(ta!=NULL)
            printf("%d ",ta->data),ta=ta->next;
        printf("
    ");
        tb=hdb;
        tb=tb->next;
        while(tb!=NULL)
            printf("%d ",tb->data),tb=tb->next;
        printf("
    ");
    }
    void div(node *a,node *b)
    {
        int cnt=1;
        node *ta,*tb,*tc;
        ta=a;
        tb=b;
        tc=a->next;
        while(tc!=NULL)
        {
            if(cnt&1)
                ta->next=tc,tc=tc->next,ta=ta->next;
           else
                tb->next=tc,tc=tc->next,tb=tb->next;
            cnt++;
        }
        ta->next=tb->next=NULL;
        return ;
    }
    int main(){
        hda=(node*)new(node);
        hdb=(node*)new(node);
        text();
        div(hda,hdb);
        print();
        return 0;
        }
    
    /*4.假设有两个已排序的单链表A和B,编写一个函数将它们合并成一个链表C而不改变其排序性。*/
    node *p, *q;
    node *mergelink()
    {
      node *h, *r;
      h=(node *)new(node);
      h->next=NULL;
      r=h;//r一直指着这条链的末尾
      while (p!=NULL && q!=NULL)
        if (p->data<=q->data)
        {
          r->next=p;
          r=p;//r=p是因为刚才把p的第一个节点接到了h上,r的地址要继续指着h这条链的话必需把r的地址指向p,也就是刚刚接到h上的这个节点
    
          p=p->next;
        }
        else
        {
          r->next=q;
          r=q;
          q=q->next;
         }
        if (p= =NULL)
    
         r->next=q;
         if (q= =NULL)
    
         r->next=p;
    
         return h;
        }
    node *mergelink(p, q);
    
    
    /*5.	设A=(a ,…,a )和B=(b ,…,bn)均为顺序表,A’和B’分别为A和B中除去最大共同前缀后的子表(例如,A=(x,y,y,z,x,z),
    B=(x,y,y,z,y,x,x,z),则两者中最大的共同前缀为(x,y,y,z),在A’=B’=空表,则A=B;若A’=空表,而B’<>空表,或者两者均不为
    空表,且A’的首元小于B’的首元,则A<B;否则A>B。(词典次序)试写一个比较A,B大小的算法(在算法中,不要破坏原表A和B,并且不一定先求得A’和B’才进行比较)。*/
    typedef struct {
        ElemType *elem;
        int       length;
        int       listsize;
    } SqList;
    
    char Compare(SqList A, SqList B)
    {
        int i,j;
        i = j = 0;
        if(A.length > A.listsize || B.length > B.listsize) return (OVERFLOW);
        if(A.elem && B.elem){
            while(i <= A.length && j <= B.length){
                if(A.elem[i] == B.elem[j]){
                    i++;
                    j++;
                }
                else
                 break;
            }
            if(!A.elem[i] && !B.elem[j]) return '=';
            if(A.elem[i] > B.elem[j]) return '>';
            if(A.elem[i] < B.elem[j]) return '<';
        }
    }
    
    /*6.设有一个用向量表示的线性表L,要求写出一个将该表逆置的过程,并允许在原表的存储空间外再增加一个附加的工作单元。*/
    void  ConvertList( Seqlist *L)
    {
    int   t;//附加单元
    int i;
    for ( i=1 ; i < L->length/2 ; i++)
    {   t = L->data[i];//交换数据
       L -> data[ i ]  = L -> data[ L -> length + 1 - i ]  ;
       L -> data[ L -> length + 1 - i ] = t  ;
    }
    }
    
    /*7.已知两个整数集合A和B,它们的元素分别依元素值递增有序存放在两个单链表HA和HB中,编写一个函数
    求出这两个集合的并集C,并要求集合C的链表的结点仍依元素值递增有序存放。(提示:求并集不是归并!)*/
    /*思路:处理好三种大于等于小于的情况就行了*/
    node*ha,*hb,*hc;
    void union(ha,ha,hc)
    {
          node*p,*q,*r,*s;
          hc=(node*)new(node);
          r=hc;p=ha;q=hb;//建立一个头结点,r总是指向HC链表的最后一个结点
          while(p!=NULL && q!=NULL)
          {
                if(p->data<q->data)
                {
                      s=(node*)new(node);
                      s->data=p->data;
                      r->next=s;
                      r=s;
                      p=p->next;
                }
                else if(p->data>q->data)
                {
                      s=(node*)new(node);
                      s->data=q->data;
                      r->next=s;
                      r=s;
                      q=q->next;
                  }
                  else  //相等的情况,取其中一个,然后后移
                  {
                      s=(node*)new(node);
                      s->data=q->data;
                      r->next=s;
                      r=s;
                      p=p->next;
                      q=q->next;
                }
        }
        if(p==NULL)
              while(q!=NULL)
              {
                  s=(node*)new(node);
                  s->data=q->data;
                  r->next=s;
                  r=s;
                  q=q->next;
              }
        if(q==NULL)
              while(p!=NULL)
              {
                  s=(node*)new(node);
                  s->data=p->data;
                  r->next=s;
                  r=s;
                  p=p->next;
              }
      r->next=NULL;
      s=hc;
      hc=hc->next;
      free(s);
    }
    
    /*8.已知两个顺序表A和B分别表示两个集合,其元素递增排列,编写一个函数求出A和B的交集C,要求C同样以元素递增的顺序表形式存储。*/
    
    /*思路:釆用归并的思想,设置两个工作指针pa和pb,对两个链表进行归并扫描,只有同时出现在两集合中的元素才链接到结果表中且仅保留一个,
    其他的结点全部释放。当一个链表遍历完毕后,释放另一个表中剩下的全部结点。比较两个节点时,小的节点指针后移一位*/
    LinkList intersection(LinkList &la,LinkList &lb) {
        pa=la->next;
        pb=lb->next;
        pc=la;
        while(pa&&pb){
            if(pa->data==pb->data) {
                pc->next=pa;
                pc=pa;
                pa=pa->next;
                u=pb;
                pb=pb->next;
                free(u);
            }
            else if (pa->data<pb->data) {
                u=pa;
                pa=pa->next;  //后移指针
                free(u) ;
            }else{
                u=pb;
                pb=pb->next;
                free (u) ;
            }
        }  //while 结束
        while(pa){
            u=pa;
            pa=pa->next;
            free (u) ;
        }
        while(pb){
            u=pb;
            pb=pb->next;
            free(u) ;
        }
        pc->next=NULL;
        free (lb) ;
        return la;
    }
    

  • 相关阅读:
    node.js fs,http
    node.js global object,util and so on
    node.js second day
    node.js
    mysql 多个and的简写
    mysql 返回结果按照指定的id顺序返回
    php file_get_contents fopen 连接远程文件
    软考例题1
    Skyline中使用AxTE3DWindowEx打开新的一个球体
    使用AE进行点的坐标投影变换
  • 原文地址:https://www.cnblogs.com/mingrigongchang/p/6246200.html
Copyright © 2020-2023  润新知