C语言实现购物车系统与单向链表操作-优快云博客

该代码示例展示了如何使用C语言实现购物车系统，包括顺序表和单向链表的数据结构。操作包括动态内存分配、顺序表的插入、删除、查找、修改和排序等。同时，也有链表的头插、头删、尾插、尾删、遍历、元素修改、查找、逆置和降序排序等功能。

顺序表练习:

请实现购物车系统，把商品[商品名称，商品属性、价格，个数]信息存储到顺序表中，请完成一下操作操作

结构体定义

typedef struct

char name[20];//名称

char arrriture[20];//属性

float price;//价格

int num;//个数

}Goods;

typedef struct

Goods data[MAXSIZE];

int len;

}seglist;

1，在堆区申请空间

2，实现顺序表数据元素在表尾录入

3，实现顺序表输出

4，实现顺序表按下标插入商品信息

5，实现顺序表按下标删除商品信息

查找商品名称key是否在购物车信息中出现6

7，修改商品名称key的购买数量，修改为n

8，删除最贵的商品信息

9，对商品总价实现升序排序

10，如果有两个商品名称相同的商品信息，则去重

11，释放堆区空间

#include"head.h"
seqlist *app()
{
    seqlist *p;
    p=malloc(MAXSIZE*sizeof(seqlist));

    if(p==NULL)
        printf("失败\n");
    p->len=0; 
    return p;
}

int seqlistempty(seqlist *p)
{
    if (p->len==0)
    {
        printf("是空表\n");
        return 0;//不能删除内容　返回０
    }
    return 1;//有内容可以删除　　返回１
}

int seqlistfull(seqlist *p)
{
    if (p->len==MAXSIZE)
    {
        printf("满了\n");
        return 0;//不能插入内容　返回０
    }
    return 1;//可以插入内容　　返回１
}

void seqlistbehindinput(seqlist *p)//只插入１组数据
{
    if(seqlistfull(p)==1)//可以操作
    {
        printf("输入\n名称　属性　价格　个数\n");
        scanf("%s %s %f %d",p->data[p->len].name,p->data[p->len].arrriture,&p->data[p->len].price,&p->data[p->len].num);
        p->len++;
    }
}

void seqlistoutput(seqlist *p)
{
    printf("目前顺序表有以下数据\n名称\t属性\t价格\t个数\n");
    for(int i=0;i<p->len;i++)
    {
        printf("%s\t%s\t%.2f\t%d\n",p->data[i].name,p->data[i].arrriture,p->data[i].price,p->data[i].num);
    }
    putchar('\n');
}

void seqlistsubinput(seqlist *p)
{
    if(seqlistfull(p)==1)
    {
        printf("输入插入的下标;\n");
        int n;
        scanf("%d",&n);
        int i=0;
        for(i=p->len;i>n;i--)
        {
            p->data[i]=p->data[i-1];
        }
        printf("输入\n名称　属性　价格　个数\n");
        scanf("%s %s %f %d",p->data[i].name,p->data[i].arrriture,&p->data[i].price,&p->data[i].num);
        p->len++;
    }
}
void seqlistsubdelete(seqlist *p)
{
    if(seqlistfull(p)==1)
    {
        printf("输入删除的下标;\n");
        int n;
        scanf("%d",&n);
        int i=0;
        for(i=n;i<p->len-1;i++)
        {
            p->data[i]=p->data[i+1];
        }
        p->len--;
    }
}

void seqlistkey_seek_output_changenum(seqlist *p)
{
    printf("输入商品ｋｅｙ\n");
    char key[20]="";
    scanf("%s/n",key);
    int i=0;
    for(i=0;i<p->len;i++)
    {
        if(!strcmp(p->data[i].name,key))
        {
            printf("找到了\n");
            printf("名称\t属性\t价格\t个数\n");
            printf("%s\t%s\t%.2f\t%d\n",p->data[i].name,p->data[i].arrriture,p->data[i].price,p->data[i].num);                
        
            printf("输入要修改的购买数量\n");
            scanf("%d",&p->data[i].num);
        }
    }
}

void seqlist_highest_price_data_delete(seqlist *p)
{
    int i,Max=0;
    for(i=0;i<p->len;i++)
    {
        if(p->data[i].price>p->data[Max].price)
        {
            Max=i;
        }
    }
    printf("Max=%d",Max);
        int j=Max;
        for(j;j<p->len-1;j++)
        {
            p->data[j]=p->data[j+1];
        }
        p->len--;

        printf("删除价格最高的商品后\n");
}

void Goods_price_up_arrange(seqlist *p)
{
    int i,j;
    Goods temp;
    for(i=1;i<=p->len-1;i++)
    {
        for(j=0;j<=p->len-1-i;i++)
        {
            if(p->data[j].price>p->data[j+1].price)
            {
                temp=p->data[j];
                p->data[j]=p->data[j+1];
                p->data[j+1]=temp;
            }
        }
    }
    printf("价格上升排序后\n");
}

void frequent_name_delete(seqlist *p)
{
    int i;
    for(i=0;i<p->len-1;i++)
    {
        for(int j=i+1;j<p->len;j++)
        {
            if(!strcmp(p->data[j].name,p->data[i].name))
            {
                int k;
                for(k=j;k<p->len-1;k++)
                {
                    p->data[k]=p->data[k+1];
                }
                p->len--;
            }
        }
    }
    printf("相同名称商品删除后\n");
}

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 3
typedef char datatype;
typedef struct
{
    char name[20];
    char arrriture[20];
    float price;
    int num;
}Goods;
typedef struct
{
    Goods data[MAXSIZE];
    int len;
}seqlist;


seqlist *app();

int seqlistempty(seqlist *p);
int seqlistfull(seqlist *p);
void seqlistbehindinput(seqlist *p);
void seqlistoutput(seqlist *p);
void seqlistsubinput(seqlist *p);
void seqlistsubdelete(seqlist *p);
void seqlistkey_seek_output_changenum(seqlist *p);
void seqlist_highest_price_data_delete(seqlist *p);
void Goods_price_up_arrange(seqlist *p);
void frequent_name_delete(seqlist *p);

#endif

#include"head.h"
// vsp xxx
int main(int argc, const char *argv[])
{
    seqlist *p;

    //申请堆空间

    
    p=app(MAXSIZE);



    seqlistbehindinput(p);
    


    seqlistoutput(p);

    seqlistsubinput(p);
    
    seqlistoutput(p);
    
/*  seqlistsubdelete(p);
    seqlistoutput(p);  */    

//  seqlistkey_seek_output_changenum(p);

//  seqlistoutput(p);

//  seqlist_highest_price_data_delete(p);
//    seqlistoutput(p);

//    Goods_price_up_arrange(p);
//    seqlistoutput(p);
    
    frequent_name_delete(p);
    seqlistoutput(p);


    free(p);  
    p=NULL; ////free后要清理野指针
    return 0;
}

单向链表练习:

链表中存储数据类型为字符串，请完成以下功能

1.在堆区电请空间

2.实现头插、头删、尾插、尾删

3，遍历链表

4，在任意位置插入

5，任意位置删除

6，按元素修改

7，按元素查找

8，单向链表逆置

9，链表降序排序

10，释放链表空间

#include"head.h"
// vsp xxx
int main(int argc, const char *argv[])
{
    linklist *p;

    //申请堆空间    
    p=app_head();

    linklist_head_input(p);
    linklist_output(p);
    

    linklist_head_delete(p);
    linklist_output(p);
    
    
    linklist_behind_input(p);
    linklist_output(p);

    linklist_behind_delete(p);
    linklist_output(p);

    linklist_sub_input(p);
    linklist_output(p);

    linklist_sub_delete(p);
    linklist_output(p);

    linklist_key_seek_change(p);
    linklist_output(p);
    
    linklist_advert(p);
    linklist_output(p);

    linklist_down_arrange(p);
    linklist_output(p);

    linklist_free(p);  
    p=NULL; ////free后要清理野指针
    return 0;
}

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct link_list
{
    union
    {
    int len;
    char data[20];
    };
     struct link_list  *next;
}linklist;
linklist *app_head();
linklist *app_node(linklist *p);
int linklist_empty(linklist *p);
void linklist_head_input(linklist *p);
void linklist_head_delete(linklist *p);
void linklist_behind_input(linklist *p);
void linklist_behind_delete(linklist *p);
void linklist_output(linklist *p);
void linklist_sub_input(linklist *p);
void linklist_sub_delete(linklist *p);
void linklist_key_seek_change(linklist *p);
void linklist_advert(linklist *p);
void linklist_down_arrange(linklist *p);
void linklist_free(linklist *p);
#endif

#include"head.h"
linklist *app_head()
{
    linklist *p;
    p=malloc(sizeof(linklist));
    if(p==NULL)
        printf("失败\n");
    p->len=0;
    p->next=NULL; 
    return p;
}
linklist *app_node(linklist *p)
{
    linklist *p1;
    p1=malloc(sizeof(linklist));
    if(p==NULL)
    {
        printf("失败\n");
        return NULL;
    }
    else
    {
    printf("输入字符串数据\n");
    scanf("%s",p1->data);
    p1->next=NULL; 
    p->len++;
    return p1;
    }
}
int linklist_empty(linklist *p)
{
    if(p->len==0)
    {    
        printf("链表为空\n");
        return 0;
    }else return 1;
}


void linklist_head_input(linklist *p)
{
    printf("头插\n");
    linklist *p1;
    p1=app_node(p);
    p1->next=p->next;
    p->next=p1;

}
void linklist_head_delete(linklist *p)
{
    if(linklist_empty(p))
    {        
        printf("头删\n");
        linklist *p1=p;
        p1=p1->next->next;
        free(p->next);
        p->next=p1;
        p->len++;
    }
}
void linklist_behind_input(linklist *p)
{
    printf("后插\n");
    linklist *p1;
    p1=app_node(p);
    while(p->next)
    {
        p=p->next;
    }
    p->next=p1;
}
void linklist_behind_delete(linklist *p)
{
    if(linklist_empty(p))
    {        
        linklist *p1=p;
        printf("尾删\n");
        while(p1->next->next)
        {
            p1=p1->next;
        }
        free(p1->next);
        p1->next=NULL;
        p->len--;
    }
}
void linklist_output(linklist *p)
{
    if(linklist_empty)
    {    
        p=p->next;
        printf("目前链表有\n");
        while(p)
        {
            printf("%s\n",p->data);
            p=p->next;
        }
    }
}
void linklist_sub_input(linklist *p)
{
    printf("要插入的下标，从１开始\n");
    int sub;
    scanf("%d",&sub);
    if(sub>0 && sub<=p->len+1)
    {
        int count=0;
        linklist *p1,*p2=p;
        p1=app_node(p);
        while(p->next&&count<sub-1)
        {
            p=p->next;
            count++;
        }
        p1->next=p->next;
        p->next=p1;

        p2->len++;
    }else printf("无法插入\n");
}

void linklist_sub_delete(linklist *p)
{
    if(linklist_empty(p))
    {
        printf("输入要删除的下标\n");
        int sub;
        scanf("%d",&sub);
        if(sub>0 && sub <=p-> len )
        {
            linklist *p1,*p2=p;
            int count=0;
            while(count<sub-1)
            {
                p=p->next;
                count++;
            }
            p1=p->next->next;
            free(p->next);
            p->next=p1;
        
            p2->len--;
        }
    }
}

void linklist_key_seek_change(linklist *p)
{
    if(linklist_empty)
    {
        printf("输入要查找的元素\n");
        char key[20];
        scanf("%s",key);
        while(p)
        {
            if(!strcmp(key,p->data))
            {
                printf("找到了,要修改为\n");
                scanf("%s",p->data);
            }
        p=p->next;
        }
    }
}

void linklist_advert(linklist *p)
{
    if(linklist_empty)
    {
        linklist *p1=p->next,*p2=p->next->next;
        p1->next=NULL;
        while(p2)
        {
            p1=p2;
            p2=p2->next;
            p1->next=p->next;
            p->next=p1;
        }
    }
    printf("逆置后\n");
}

void linklist_down_arrange(linklist *p)
{
    if(linklist_empty(p))
    {
        linklist *p1=p->next; 
        p->next=NULL;
        while(p1)
        {
            linklist *p2=p1;
            p1=p1->next;
            
            if(p->next==NULL)
            { 
                p2->next=p->next;
                p->next=p2;
            }
            else
            {
                linklist *p3=p;
                while(p3->next!=NULL && strcmp(p3->next->data,p2->data)>0)
                {
                    p3=p3->next;
                }
                p2->next=p3->next;
                p3->next=p2;
            }
        }
    printf("降序后为\n");    
    }
}

void linklist_free(linklist *p)
{
    linklist *p1;
    while(p)
    {
        p1=p;
        p=p->next;
        free(p1);
    }
    
}