数据结构---线性表的应用实例

其他 2018-10-26 06:24:09 阅读次数: 0

 将顺序表(a1,a2,a3,...,an)重新排列为以a1为界的两部分：a1前面的值均比a1小，后面的值均比a1大(数据类型均具有可比性，都设为整型）

#include <stdio.h>
#include <stdlib.h>
#define maxsize 100

typedef struct  //顺序表结构
{
    int data[maxsize];
    int last;
}seqlist;

 seqlist *init_seqlist(int arrsize)  //顺序表初始化
 {
     seqlist *L;
     L=(seqlist*)malloc(sizeof(seqlist));
     L->last=arrsize-1;
     return L;
 }

void input(seqlist *L)
{
    int i;
    for(i=0;i<=L->last;i++)
    {
        scanf("%d",&L->data[i]);
    }
}

void show(seqlist*L)
{
    int i;
    for(i=0;i<=L->last;i++)
    {
        printf("%d ",L->data[i]);
    }
}

void part(seqlist*L)
{
    int x,y,i,j;
    x=L->data[0];//将基准置入x中
    for(i=1;i<=L->last;i++)//注意i从1开始
    {
        if(L->data[i]<x)
        {
            y=L->data[i];//记录比基准小的数，防止挪位后丢失
            for(j=i-1;j>=0;j--)//该数前的数字向后挪一位
            {
                L->data[j+1]=L->data[j];
                L->data[0]=y;//将小的数置入第一个数
            }
        }
    }
}

int main()
{
    int arrsize;
    seqlist *L;
    scanf("%d",&arrsize);
    L=init_seqlist(arrsize);
    input(L);
    part(L);
    show(L);
    return 0;
}

两个递增有序的单链表A和B，合成链表C，不改变排序性。

输入输出样例：1组

  • 样例输入： 
    5 //A链表元素个数
2 3 4 10 11 //A链表元素内容，递增有序
3 //B链表元素个数
5 6 12 //B链表元素内容，递增有序

样例输出：

2 3 4 5 6 10 11 12
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define maxsize 1000
typedef struct
{
    int data[maxsize];
    int last;
} seqlist;

seqlist *init_seqlist(int arrsize)
{
    seqlist *L;
    L=(seqlist *)malloc(sizeof(seqlist));
    L->last=arrsize-1;
    return L;
}

void input(seqlist *A)
{
    int i;
    for(i=0; i<=A->last; i++)
    {
        scanf("%d",&A->data[i]);
    }
}

void bubblesort(seqlist *A)//j将表进行冒泡排序
{
    int i,j,temp;
    for(i=0; i<A->last; i++)
    {
        for(j=i+1; j<A->last+1; j++)
        {
            if(A->data[j]<A->data[i])
            {
                temp=A->data[j];
                A->data[j]=A->data[i];
                A->data[i]=temp;
            }
        }
    }
}

seqlist * merge(seqlist *A,seqlist *B,seqlist *C)
{
    int i=0,j=0,k=0;
    while(i<=A->last&&j<=B->last)
    {
        if(A->data[i]<B->data[j])
        {
            C->data[k++]=A->data[i++];
        }
        else
        {
            C->data[k++]=B->data[j++];
        }
    }
    while(i<=A->last)//表B先结束
    {
        C->data[k++]=A->data[i++];
    }
    while(j<=B->last)//表A先结束
    {
        C->data[k++]=B->data[j++];
    }
    C->last=k-1;
    return C;
}

int main()
{
    int i,arrsize1,arrsize2;
    seqlist *A,*B,*C;
    C=(seqlist *)malloc(sizeof(seqlist));
    scanf("%d",&arrsize1);
    A=init_seqlist(arrsize1);
    input(A);
    scanf("%d",&arrsize2);
    B=init_seqlist(arrsize2);
    input(B);
    bubblesort(A);
    bubblesort(B);
    C=merge(A,B,C);
    for(i=0;i<=C->last;i++)
    {
        printf("%d ",C->data[i]);
    }
  return 0;
}

顺序表A中删除值在x~y（x<=y）之间的所有元素。

输入输出样例：1组

  • 样例输入： 
    7 //输入顺序表中结点个数，数组规模可以很大。但是用这个值来指定当前大数组中的前几个用于顺序表中的值
1 2 3 3 4 4 2 //输入当前顺序表中的元素都有哪些
3 6 //分别输入x和y的值，即范围
  • 样例输出： 
    1 2 2 
    #include <stdio.h>
#include <stdlib.h>
#define maxsize 100

typedef struct
{
    int data[maxsize];
    int last;
} seqlist;

seqlist *init_seqlist(int arrsize)
{
    seqlist *L;
    L=(seqlist *)malloc(sizeof(seqlist));
    L->last=arrsize-1;
    return L;
}

seqlist *result_seqlist(seqlist *L,int x,int y)
{
    int k=0,j,i;
    seqlist *S;
    S=(seqlist *)malloc(sizeof(seqlist));

        if(x==y)
        {
            for(i=0; i<=L->last; i++)
            {
                if(L->data[i]==x)
                {
                    for(j=i+1; j<=L->last; j++)
                    {
                        L->data[j-1]=L->data[j];
                    }
                    L->last--;i--;
                }
                else
                {
                    S->data[k++]=L->data[i];
                }
            }
        }
        else  //x，y不相等
        {
            for(i=0; i<=L->last; i++)
            {
                if(L->data[i]>=x&&L->data[i]<=y) 
                {
                    for(j=i+1; j<=L->last; j++) //将数据进行向前移一位，即删除在此范围内的数
                    {
                        L->data[j-1]=L->data[j];
                    }
                    L->last--;i--; //表长减一，i减一，从挪位后的新一个数据判断
                }
                else
                {
                    S->data[k++]=L->data[i];
                }
            }

    }
    S->last=k-1;
    return S;
}

int main()
{
    int i,arrsize,x,y;
    seqlist *L,*S;
    scanf("%d",&arrsize);
    L=init_seqlist(arrsize);
    for(i=0; i<=L->last; i++)
    {
        scanf("%d",&L->data[i]);
    }
        scanf("%d %d",&x,&y);
    S=result_seqlist(L,x,y);
    for(i=0; i<=S->last; i++)
    {
        printf("%d ",S->data[i]);
    }
  return 0;
}

    已知带头结点的单链表L中的结点是按整数值递增排列的，试写一算法，将值为x的结点插入到表L中，使得L仍然递增有序（这里我们将插入和排序用一个函数完成，不用排序和插入两个函数实现）

    #include <stdio.h>
#include <stdlib.h>
#define maxsize 1000
typedef struct node
{
    int data;
    struct lnode *next;
} LNode,*LinkList;

LinkList init_LNode()
{
    LinkList L;
    L=(LinkList)malloc(sizeof(LNode));
    L->data=0;
    L->next=NULL;
    return L;
}

LinkList insert_linklist(LinkList L,int insert_data)
{
    LNode *p,*q,*s;
    p=L->next;
    q=p;
    while(p!=NULL&&insert_data<p->data)
    {
        q=p;//q记录前驱结点
        p=p->next;
    }
    if(p==NULL)//为空代表走到了最后或表开始为空
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=insert_data;
        s->next=NULL;
        q->next=s;
    }
    else
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=insert_data;
        s->next=p;
        q->next=s;
    }
    return L;
}

void output_link(LinkList L)
{
    LNode *p;
    p=L->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
}

int main()
{
    int input_data;
    LinkList L=init_LNode();
    printf("please input the data for the list,100 represent the end\n");
    scanf("%d",&input_data);
    while(input_data!=100)
    {
        L=insert_linklist(L,input_data);
        scanf("%d",&input_data);
    }
    output_link(L);//输入结束，输出该表内容
    printf("please input the insert data:");
    scanf("%d",&input_data);
    L=insert_linklist(L,input_data);
    output_link(L);
    return 0;
}

    下面的实例就只写核心过程：

  • 实现单链表的逆置

    typedef struct lnode
{
    int data;
    struct lnode *next;
}LNode,*LinkList;

void reverse(LinkList* L)
{
    LNode *p;
    p=L->next; //p指向第一个数据结点
    L->next=NULL;//将原链表置为空
    while(p)
    {
        q=p;//q为p的前驱结点
        p=p->next;
        q->next=L->next;//头插法实现逆转
        L->nect=q;
    }
}

    删除一链表中的重复结点

    typedef struct lnode
{
    int data;
    struct lnode *next;
}LNode,*LinkList;

void put_linklist(LinkList *L)
{
    LinkList *q,*p,*r;
    p=L->next;//p指向第一个数据结点
    while(p->next)//p作为基准比较
    {
        q=p;
        if(p==NULL)return;
        while(q->next)//q作为待删前驱结点  
        {
            if(q->next->data==p->data)
            {
                r=q->next;//r为待删结点
                q->next=r->next;
                free(r);
            }
            q=q->next;
        }
        p=p->next;
    }
}

    有两个单链表A，B，其中元素递增且有序，编写算法将A，B归并成一个按元素之递减（允许有相同值）有序的链表C，要求用A，B中的原结点形成，不能重新申请结点

    typedef struct lnode
{
    int data;
    struct lnode *next;
}LNode,*LinkList;

LinkList merge(LinkList A,LinkList B)//设A，B为带头结点的单链表
{
    LNode *p,*q,*s;LinkList C;
    p=A->next;q=B->next;
    C=A;
    free(B);
    while(p&&q)
    {
        if(p->data<q->data)//从原A，B中取下较小者
        {
            s=p;p=p->next;
        }
        else
        {
            s=q;q=q->next;
        }
        s->next=C->next;//插到C的头部
        C->next=s;
    }
    if(p==NULL)p=q;//p已结束
    while(p)//将剩余的结点一个个摘下，插到C表的头部
    {
        s=p;p=p->next;
        s->next=C->next;
        C->next=s;
    }
}

    将单链表转换为双向循环链表

    typedef struct dlnode
{
    int data;
    struct dlnode *next,*prior;
} DLNode,*DLinkList;

DLinkList Creat_DLinkList(LinkList L)
{
    DLinkList H;
    DLNode *s,,*p,*rear;
    H=(DLNode*)malloc(sizeof(DLNode));//生成H的头结点
    H->next=H;//构造H为空的双向循环链表
    H->prior=H;
    rear=H;
    p=L->next;//p指向L的第一个结点
    while(p)
    {
        s=(DLNode*)malloc(sizeof(DLNode));
        s->data=p->data;//申请、填充结点
        s->next=rear->next;
        s->prior=rear;
        rear->next=s;
        H->prior=s;//结点s插到H的链表尾
        rear=s;//修改H的尾指针rear
        p=p->next;
    }
    return H;
}

猜你喜欢

转载自blog.csdn.net/weixin_42107106/article/details/82817061
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022