精华内容
下载资源
问答
  • 1、建立一个顺序表,要求从键盘输入10个整数,并将该顺序...3、用函数实现顺序表的插入和删除操作。由用户输入待插入元素及插入位置,将完成插入后的顺序表输出;由用户输入删除第几个元素,将完成删除后的顺序表输出。
  • C语言实现顺序表基本操作

    千次阅读 2019-07-31 15:42:08
    C语言实现顺序表基本操作

    C语言实现顺序表的基本操作,包括增删查操作以及顺序表的合并

    SequentialList.h

    #include <stdio.h>
    #include <stdlib.h>
    #define MAXSIZE 30
    
    typedef int DataType;
    //顺序表格式定义
    typedef struct
    {
        DataType Data[MAXSIZE];  //数据域,存放数据
        int last;       //记录最后顺序表一个元素下标,空表为-1
    }SeqList;
    //定义三个顺序表LA,LB,LC
    SeqList LA,LB,LC;
    
    //判空
    int IsEmpty(SeqList L);
    //判满
    int IsFull(SeqList L);
    
    //初始化顺序表
    int InitSeqList(SeqList* L);
    
    //在下标i处插入数据
    int InsList(SeqList* L,int i,int e);
    //递增按序插入数据
    int InsertList(SeqList* L,int e);
    
    //删除下标为i的元素
    int DelList(SeqList* L,int i);
    //删除数据e
    int DeleteList(SeqList* L,int e);
    
    //查找并返回下标为i的元素
    int GetData(SeqList L,int i);
    //查找变量e并返回下标
    int Locate(SeqList L,int e);
    
    //显示L所有数据
    int Show(SeqList L);
    
    //合并有序顺序表LA,LB
    int MergeList(SeqList* LA,SeqList* LB,SeqList* LC);
    
    //状态判断函数,判断并输出操作的运行状态
    int State(int i);
    
    //对顺序表L进行操作
    int Operation(SeqList* L);
    
    //主界面
    int MainMenu();
    

    SequentialList.c

    #include <stdio.h>
    #include <stdlib.h>
    #include "SequentialList.h"
    
    //初始化顺序表
    int InitSeqList(SeqList* L)
    {
        //将顺序表last值赋为-1,将顺序表置为空表
        L->last = -1;
        return 0;
    }
    
    //在下标i处插入数据
    int InsList(SeqList* L,int i,int e)
    {
        int j;
        if(IsFull(*L))
            return -1;      //表已满,无法插入
        if((i < 0)||(i > L->last + 1))
            return 0;       //插入位置i不合法
        if(i == L->last + 1)
        {
            L->Data[i] = e;
            L->last++;
            return 1;        //插入成功返回1
        }
        else
        {
            for(j = L->last;j >= i; j--)
                L->Data[j+1] = L->Data[j];
            L->Data[i] = e;
            L->last++;
            return 1;        //插入成功返回1
        }
    }
    
    //按递增顺序插入数据e
    int InsertList(SeqList* L,int e)
    {
        int i;
        if(IsEmpty(*L))
        {
            L->Data[0] = e;
            L->last++;
            return 1;     //插入成功返回1
        }
        else
        {
            for(i = 0;i <= L->last; i++ )
            {
                if(L->Data[i] > e)
                    break;
            }
            return InsList(L,i,e);
             //在下标i处插入数据并返回其返回值
        }
    }
    
    //删除下标为i的元素
    int DelList(SeqList* L,int i)
    {
        int j;
        if((i < 0)||(i > L->last))
            return 0;           //删除位置不合法返回0
        if(i < L->last)
            for(j = i;j < L->last; j++ )
                L->Data[j] = L->Data[j+1];
        L->last--;
        return 1;               //删除成功返回1
    }
    
    //删除数据e
    int DeleteList(SeqList* L,int e)
    {
        int i = Locate(*L,e);
        if(i >= 0)
            return DelList(L,i);
        return -2;
    }
    
    //返回下标为i的数据
    int GetData(SeqList L,int i)
    {
        if((i < 0)||(i > L.last))
            return 0;        //位置不合法返回0
        return L.Data[i];           //操作成功返回1
    }
    
    //查找e返回下标
    int Locate(SeqList L,int e)
    {
        int i = 0;
        while((i <= L.last)&&(L.Data[i] != e))
            i++;
        if(i <= L.last)
            return i;  //找到位置则1
        return -1;         //未找到返回-2
    }
    
    //判空
    int IsEmpty(SeqList L)
    {
        if(L.last == -1)
            return 1;  //表为空返回1
        return 0;
    }
    
    //判满
    int IsFull(SeqList L)
    {
        if(L.last == MAXSIZE - 1)
            return 1;   //表已满返回1
        return 0;
    }
    
    //显示顺序表中所有元素
    int Show(SeqList L)
    {
        int i;
        for(i = 0;i <= L.last; i++)
            printf("\t%d. %d\n",i,L.Data[i]);
        return 0;
    }
    
    //状态判断函数,判断并输出操作的运行状态
    int State(int i)
    {
        if(i == -1)
            printf("\t顺序表已满\n");
        else if(i == 0)
            printf("\t输入位置不合法\n");
        else if(i == -2)
            printf("\t在顺序表中未找到该数据\n");
        else if(i == -3)
            printf("\t顺序表为空\n");
        else
            printf("\t操作成功\n");
        return 0;
    }
    
    //对顺序表进行操作
    int Operation(SeqList* L)
    {
        int i,e,k,m;
        //i操作数,e增删查的数据,k要操作的位置
        while(1)
        {
            system("cls");
            printf("\t1.按序插入数据e\n");
            printf("\t2.删除第k个数据\n");
            printf("\t3.删除数据e\n");
            printf("\t4.查找数据e\n");
            printf("\t5.显示所有数据\n");
            printf("\t0.返回主界面\n");
            scanf("%d",&i);
            switch(i)
            {
            case 1:
                printf("请输入要插入的数据");
                scanf("%d",&e);
                State(InsertList(L,e));
                system("pause");
                break;
            case 2:
                printf("请输入要删除数据的位置");
                scanf("%d",&k);
                State(DelList(L,k-1));
                system("pause");
                break;
            case 3:
                printf("请输入要删除的数据");
                scanf("%d",&e);
                State(DeleteList(L,e));
                system("pause");
                break;
            case 4:
                printf("请输入要查找的数据");
                scanf("%d",&e);
                m =Locate(*L,e);
                if(m >= 0)
                    printf("\n%d的下标为%d\n",e,m);
                system("pause");
                break;
            case 5:
                Show(*L);
                system("pause");
                break;
            case 0:
                return 0;
                break;
            default:
                break;
            }
        }
    }
    
    //合并有序顺序表LA,LB
    int MergeList(SeqList* LA,SeqList* LB,SeqList* LC)
    {
        int i,j,k;
        i = j = k = 0;
        while((i <= LA->last)&&(j <= LB->last))
        if(LA->Data[i] < LB->Data[j])
        {
            LC->Data[k] = LA->Data[i];
            i++;
            k++;
        }
        else
        {
            LC->Data[k] = LB->Data[j];
            j++;
            k++;
        }
        while(i <= LA->last)
        {
            LC->Data[k] = LA->Data[i];
            i++;
            k++;
        }
        while(j <= LB->last)
        {
            LC->Data[k] = LB->Data[j];
            j++;
            k++;
        }
        LC->last = LA->last + LB->last + 1;
        return 0;
    }
    
    //主界面
    int MainMenu()
    {
        int i;
        printf("\t1.对顺序表LA进行操作\n");
        printf("\t2.对顺序表LB进行操作\n");
        printf("\t3.合并顺序表LA和LB\n");
        printf("\t4.查看LC\n");
        printf("\t0.退出系统\n");
        scanf("%d",&i);
        switch(i)
        {
        case 1:
            Operation(&LA);
            break;
        case 2:
            Operation(&LB);
            break;
        case 3:
            MergeList(&LA,&LB,&LC);
            break;
        case 4:
            Show(LC);
            break;
        case 0:
            exit(0);
            break;
        default:
            break;
        }
        system("pause");
        return 0;
    }
    
    

    main.c

    #include <stdio.h>
    #include <stdlib.h>
    #include "SequentialList.h"
    
    int main()
    {
        InitSeqList(&LA);
        InitSeqList(&LB);
        InitSeqList(&LC);
        while(1)
        {
            system("cls");
            MainMenu();
        }
        return 0;
    }
    
    
    展开全文
  • 主要介绍了C语言实现顺序表基本操作汇总,对学习数据结构的朋友有一定的借鉴价值,需要的朋友可以参考下
  • c语言顺序表基本操作

    万次阅读 多人点赞 2018-06-30 15:18:36
    下面是顺序表基本操作c语言版的数据结构书上写的操作都实现了因为总体代码太长如果写在一个class中要近500行,阅读和修改都不方便,所以采用分开写,希望大家以后写较长的程序时也采用这种方法,自己运行的所有...

    下面是顺序表的基本操作,c语言版的数据结构书上写的操作都实现了

    因为总体代码太长如果写在一个class中要近500行,阅读和修改都不方便,所以采用分开写,希望大家以后写较长的程序时也采用这种方法,自己运行的所有功能都能实现,而且个人感觉界面还是比较人性化的,大家还有什么意见或者程序有什么问题都可以在评论区提出,我会及时修改的。

    
    
    seqlist.h
    
    #ifndef SEQLIST_H
    #define SEQLIST_H
    #include <stdio.h>
    #include <malloc.h>
    #define SEQLISR_INIT_SIZE 5
    #define INC_SIZE 3
    
    typedef int ElemType;
    typedef struct Seqlist
    {
        ElemType *base;//指针域
        int capacity;//顺序表容量
        int size;//表的大小
    }Seqlist;
    
    void create_list(Seqlist *list);//顺序表元素的输入
    bool Inc(Seqlist *list);//增加顺序表的容量
    void InitSeqlist(Seqlist *list);//初始化顺序表
    void push_back(Seqlist *list,ElemType x);//在顺序表的末尾插入元素
    void push_front(Seqlist *list,ElemType x);//在顺序表的头部插入元素
    void show_list(Seqlist *list);//显示顺序表的元素
    void pop_back(Seqlist *list);//删除顺序表的最后一个元素
    void pop_front(Seqlist *list);//删除顺序表的第一个元素
    void insert_pos(Seqlist *list,int pos,ElemType x);//在顺序表的指定位置插入数据
    int find(Seqlist *list,ElemType key);//查找元素key的下标
    int length(Seqlist *list);//求顺序表的长度
    void delete_pos(Seqlist *list,int pos);//删除顺序表中指定位置的数据
    void delete_val(Seqlist *list,int key);//删除顺序表中值为key的元素
    void sort(Seqlist *list);//冒泡排序
    void reverse(Seqlist *list);//逆置顺序表
    void clear(Seqlist *list);//清除顺序表中的所有元素
    void destroy(Seqlist *list);//摧毁顺序表
    void merge(Seqlist *lt,Seqlist *la,Seqlist *lb);//吧两个表合为一个表
    
    
    
    #endif // SEQLIST_H
    seqlist.cpp
    
    #include "seqlist.h"
    
    void InitSeqlist(Seqlist *list)//初始化顺序表,创建一个名字为List的线性表,list通过结构体定义
    {
        list->base=(ElemType*)malloc(sizeof(ElemType)*SEQLISR_INIT_SIZE);//对表list分配空间
        if(!list->base)
            exit(-1);
        list->capacity=SEQLISR_INIT_SIZE;//顺序表的容量
        list->size=0;//顺序表的大小/长度,表示当前顺序表中无任何内容
    }
    
    bool Inc(Seqlist *list)//增加顺序表的容量
    {
    
        ElemType *newbase=(ElemType*)realloc(list,sizeof(ElemType)*(list->capacity+INC_SIZE));//重新分配内存空间,增减INC个容量
        if(newbase==NULL)
            printf("内存分配失败!");
    
        list->base=newbase;
        list->capacity+=INC_SIZE;
    
    }
    
    void create_list(Seqlist *list)
    {
        int i,x;
        printf("请确定输入元素的个数:");
        scanf("%d",&i);
        printf("请输入元素\n");
    
        for(int j=0; j<i; j++)
        {
            scanf("%d",&x);
            list->base[j]=x;
        }
        list->size=i;
    }
    
    void push_back(Seqlist *list,ElemType x)//在顺序表的尾部插入元素
    {
        if(list->size>=list->capacity&&!Inc(list))
        {
            printf("顺序表已满,无法在尾部插入新元素");
            return;
        }
        list->base[list->size]=x;
        list->size++;
    }
    
    void push_front(Seqlist *list,ElemType x)//在顺序表头部插入新元素
    {
        if(list->size>=list->capacity&&!Inc(list))
        {
            printf("顺序表已满,无法在尾部插入新元素");
            return;
        }
        for(int i=list->size; i>0; i--)
        {
            list->base[i]=list->base[i-1];
        }
        list->base[0]=x;
        list->size++;
    }
    
    void show_list(Seqlist *list)//顺序表的打印输出
    {
        for(int i=0; i<list->size; i++)
        {
            printf("%d\n",list->base[i]);
        }
    }
    
    void pop_front(Seqlist *list)//删除表头元素
    {
        if(list->size==0)
        {
            printf("顺序表为空,无法删除元素");
            return;
        }
        for(int i=0; i<list->size-1; i++)
        {
            list->base[i]=list->base[i+1];
        }
        list->size--;
    }
    
    void pop_back(Seqlist *list)//删除最后一个元素
    {
        if(list->size==0)
        {
            printf("顺序表为空,无法删除元素");
            return;
        }
        list->size--;//这也太聪明了,直接减少一个元素
    }
    
    int length(Seqlist *list)
    {
        return list->size;
    }
    
    void insert_pos(Seqlist *list,int pos,ElemType x)//在指定位置插入元素
    {
        if(pos<0||pos>list->size)
        {
            printf("插入位置不合法,无法插入元素");
            return;
        }
        if(list)
            for(int i=list->size; i>pos; i--)
            {
                list->base[i]=list->base[i-1];
            }
        list->base[pos]=x;
        list->size++;
    }
    
    int find(Seqlist *list,ElemType key)//寻找key的位置
    {
        for(int i=0; i<list->size; i++)
        {
            if(list->base[i]==key)
                return i;
        }
        return -1;
    }
    
    void delete_pos(Seqlist *list,int pos)//删除指定位置的元素
    {
        if(pos<0||pos>=list->size)
        {
            printf("删除位置不合法");
            return;
        }
        for(int i=pos; i<list->size-1; i++)
        {
            list->base[i]=list->base[i+1];
        }
        list->base--;
    }
    
    void delete_val(Seqlist *list,int key)//删除指定元素
    {
        int pos=find(list,key);
        if(pos==-1)
        {
            printf("顺序表中没有这个元素");
            return;
        }
        delete_pos(list,pos);
    }
    
    void sort(Seqlist *list)
    {
        for (int i = 0; i < list->size - 1; i++) //排序的趟数(例如5个数据需要比较4趟)
        {
            for (int j = 0; j < list->size - 1 - i; j++) //每一趟比较中的比较次数(例如5个数据在第0趟需要比较4次)
            {
                if (list->base[j] > list->base[j + 1])
                {
                    ElemType temp = list->base[j];
                    list->base[j] = list->base[j + 1];
                    list->base[j + 1] = temp;
                }
            }
        }
    }
    
    void reverse(Seqlist *list)//将顺序表倒置
    {
        if(list->size==0||list->size==1)
            return;
        int low=0,high=list->size-1;
    
        while(low<high)
        {
            ElemType temp=list->base[low];
            list->base[low]=list->base[high];
            list->base[high]=temp;
            low++;
            high--;
        }
    }
    
    void clear(Seqlist *list)
    {
        list->size=0;
    }
    
    void destroy(Seqlist *list)//摧毁顺序表
    {
        free(list->base);
        list->base=NULL;
        list->capacity=0;
        list->size=0;
    }
    
    void merge(Seqlist *lt,Seqlist *la,Seqlist *lb)//把两个顺序表合并为一个
    {
        lt->capacity=la->size+lb->size;
        lt->base=(ElemType*)malloc(sizeof(ElemType)*lt->capacity);
        if(!lb->base)
            exit(-1);
        int ia=0,ib=0,ic=0;
        while(ia<la->size&&ib<lb->size)
        {
            if(la->base[ia]<lb->base[ib])
            {
                lt->base[ic++]=la->base[ia++];
            }
            else
            {
                lt->base[ic++]=lb->base[ib++];
    
            }
        }
        while(ia<la->size)
        {
            lt->base[ic++]=la->base[ia++];
        }
        while(ib<lb->size)
        {
            lt->base[ic++]=lb->base[ib++];
        }
        lt->size=la->size+lb->size;
        show_list(lt);
    }


    #include "seqlist.h"
    
    int main()
    {
        Seqlist list;
        InitSeqlist(&list);
        //create_list(&list);
        ElemType item;
        int pos;
        int select=1;
        printf("*******************************************\n");
        printf("*[1]  push_back        [2]  push_front    *\n");
        printf("*[3]  show_list        [4]  pop_back      *\n");
        printf("*[5]  pop_front        [6]  insert_pos    *\n");
        printf("*[7]  find             [8]  length        *\n");
        printf("*[9]  delete_pos       [10] delete_value  *\n");
        printf("*[11] sort             [12] reverse       *\n");
        printf("*[13] clear            [14] merge         *\n");
        printf("*[0]  quit_system                         *\n");
        printf("*******************************************\n");
        while(select)
        {
    
            printf("请选择:>>");
            scanf("%d",&select);
            if(select==0)
                break;
            switch(select)
            {
            case 1:
                printf("请输入要插入的数据(-1结束)");
                while(scanf("%d",&item),item!=-1)
                {
                    push_back(&list,item);
                }
                break;
            case 2:
                printf("请输入要插入的数据(-1结束)");
                while(scanf("%d",&item),item!=-1)
                {
                    push_front(&list,item);
    
                }
                break;
            case 3:
                show_list(&list);
                break;
            case 4:
                pop_back(&list);
                break;
            case 5:
                pop_front(&list);
                break;
            case 6:
                printf("请输入要插入的数据:");
                scanf("%d",&item);
                printf("请输入要插入的位置:");
                scanf("%d",&pos);
                insert_pos(&list,pos,item);
                break;
            case 7:
                printf("请输入要查找的数据:");
                scanf("%d",&item);
                pos=find(&list,item);
                if(pos=-1)
                    printf("要查找的元素不在顺序表中");
                else
                    printf("查找元素的在顺序表中的下标位置为:%d\n",pos);
                break;
            case 8:
                printf("顺序表的长度为%d",length(&list));
                break;
            case 9:
                printf("请输入要删除的值的下标位置:");
                scanf("%d",&pos);
                delete_pos(&list,pos);
                break;
            case 10:
                printf("请输入哟啊删除的值");
                scanf("%d",&item);
                delete_val(&list,item);
                break;
            case 11:
                sort(&list);
                break;
            case 12:
                reverse(&list);
                break;
            case 13:
                clear(&list);
                break;
            case 14:
                Seqlist mylist,yourlist;
                ElemType item1,item2;
                InitSeqlist(&mylist);
                InitSeqlist(&yourlist);
                printf("请输入顺序表1中的元素值");
                while(scanf("%d",&item1),item1!=-1)
                {
                    push_back(&mylist,item1);
                }
                printf("请输入顺序表2中的元素值");
                while(scanf("%d",&item2),item2!=-1)
                {
                    push_back(&yourlist,item2!=-1);
                }
                merge(&list,&mylist,&yourlist);
                destroy(&mylist);
                destroy(&yourlist);
                break;
            case 15:
                create_list(&list);//顺序表的创建,输入数据
                break;
            default:
                printf("输入的选择错误");
                break;
    
    
            }
        }
        destroy(&list);
    }




    展开全文
  • 数据结构C语言完成顺序表基本操作,上数据结构课的时候的任务,可以在vs上实现,用switch函数选择
  • 主要介绍了c语言实现顺序表基本操作,需要的朋友可以参考下
  • c语言 顺序表基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据...

    c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出)

    1、创建、申请空间

    2、初始化、顺序表数据结构大小、长度

    3、赋值、顺序表数据结构赋值

    4、插入、在指定位置插入数据,后续数据循环后移,长度增加,空间大小增加或者不变

    5、删除、删除指定位置的数据,后续数据循环前移,长度减小、空间大小不变

    6、查询、查看指定数据是否在顺序表结构中

    7、替换、将顺序表结构中指定数值替换为另外的数值

    8、输出、输出顺序表结构中存储的数据(根据长度大小输出)

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <Windows.h>
    #define Size 5
    //显示日期、时间、文件信息
    void xinxi()
    {
    
    	printf("Date : %s\n", __DATE__);
    	printf("Time : %s\n", __TIME__);
    	printf("File : %s\n", __FILE__);
    	printf("Line : %d\n", __LINE__);
    	printf("\n***以下是程序部分***\n\n");
    	
    }
    //定义顺序表结构
    typedef struct Table
    {
    	int *head;//类似于数组指针
    	int length;//数据长度
    	int size;//机构大小
    }table;
    //初始化顺序表结构
    table initcreact()
    {
    	table t;
    	if ((t.head = (int *)malloc(Size*sizeof(int))) == NULL)
    	{
    		printf("申请存储空间失败!");
    			exit(1);
    	}
    	t.length = 0;//初始化长度为 0
    	t.size = Size;//结构大小
    	return t;
    }
    //结构赋值
    table fuzhi(table t)
    {
    	int i;
    	for (i = 0; i < t.size; i++)
    	{
    		t.head[i] = i + 1;
    		t.length++;//长度随赋值情况增加
    	}
    	return t;
    }
    //输出结构存储情况
    table prt(table t)
    {
    	printf("存储的数据如下:\n");
    	for (int i = 0; i < t.length; i++)
    		printf("%d ", t.head[i]);
    	printf("\n");
    	return t;
    }
    //插入数据
    table insert(table t,int elme,int add)
    {
    	if (t.length == t.size)//如果数据结构已满,增加存储空间
    		t.head= (int *)realloc(t.head, (t.size + 1) * sizeof(int));
    	if (t.head == NULL)
    	{
    		printf("申请存储空间失败!\n");
    		exit(1);
    	}
    	else t.size++;//空间大小增加
    	int i = t.size;
    	for (; i >= elme-1; i--)//数据循环后移
    		t.head[i] = t.head[i - 1];
    	t.head[elme-1] = add;//指定位置插入数据,赋值
    	t.length++;//长度增加
    	return t;
    }
    //删除指定数据
    table deleter(table t, int elme)
    {
    	int i = elme-1;
    	for (; i <= t.size; i++)
    		t.head[i] = t.head[i +1];
    	t.head[i] = 0;
    	t.length--;
    	return t;
    }
    //查询指定数据,返回在数据结构中的位置
    int select(table t, int elme)
    {
    	int i;
    	for (i = 0; i <= t.length; i++)
    	{
    		if (t.head[i] == elme)
    			return i+1;
    	}
    	return -1;
    }
    //替换指定数据
    table tihuan(table t, int elme, int add)
    {
    	int i=select(t,elme);
    	
    		t.head[i-1] = add;
    		return t;
    	
    }
    //主函数
    int main()
    {
    	xinxi();
    	table t = initcreact();
    	t = fuzhi(t);
    	t = prt(t);
    	int elme;
    	printf("请输入插入的位置:");
    	scanf("%d", &elme);
    	int add;
    	printf("请输入插入数据:");
    	scanf("%d", &add);
    	if (elme > t.size+1 || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = insert(t, elme,add);
    	t = prt(t);
    	printf("请输入删除的位置:");
    	scanf("%d", &elme);
    	if (elme > t.size || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = deleter(t, elme);
    	t = prt(t);
    	printf("查找 5 的位置\n");
    	elme = select(t, 5);
    	printf("5 的位置是 %d\n", elme);
    
    	t = prt(t);
    	printf("用 55 替换 5\n");
    	tihuan(t, 5, 55);
    	t = prt(t);
    
    	system("pause");
    	return 0;
    }

     

     

    展开全文
  • 数据结构c语言 顺序表操作 源代码 运行正常
  • C语言顺序表基本操作

    千次阅读 2016-10-23 21:55:12
    #include #include #include //调用exit();函数 #define N 10 typedef struct List { int a[N]; int last;//相当于就是伪指针。用来表示有效数组的下标 ...//创建顺序表。 void traverse_list
    #include <stdio.h>
    
    #include <malloc.h>
    #include <stdlib.h>//调用exit();函数
    #define N 10
    typedef struct List
    {
    int a[N];
    int last;//相当于就是伪指针。用来表示有效数组的下标
    } NODE,*Node;
    //函数声明;
    Node create_list();//创建顺序表。
    void traverse_list(Node);//遍历顺序表
    void search_list(Node,int);//查找
    void insert_list(Node,int,int);//插入
    void delete_list(Node,int,int*);//将删除的值输出来。只能指针改变自己的值
    void sort_list(Node);//排序顺序表
    /*int Is_Full(Node);
    int Is_Empty(Node);*/


    int main(void)
    {
    Node Head;//定义结构体指针,用来存放数组的首地址
    int postion,val,val1,postion1,*val2;
    Head=create_list();
    traverse_list(Head);
    /*printf("请输入你要查找的值:");//没有按位置查找
    scanf("%d",&val);
    search_list(Head,val);
    printf("请输入你要插入的位置:");
    scanf("%d",&postion);
    printf("请输入你要插入的值:");
    scanf("%d",&val1);
    insert_list(Head,postion,val1);
    traverse_list(Head);*/
    /*printf("请输入你要删除的位置:");
    scanf("%d",&postion1);
    delete_list(Head,postion1,val2);


    traverse_list(Head);*/
    printf("排序后的顺序表为:");
    sort_list(Head);
    traverse_list(Head);
    return 0;


    }
    Node create_list()//将初始话顺序表的同时创建
    {
    Node p;
    int n,i,val;
    p=(Node)malloc(sizeof(NODE));
    if(p==NULL)
    {

    printf("动态内存分配失败!\n");
    exit(-1);//终止程序。
    }
      p->last=0;//初始化。
      printf("请输入你要顺序表的值的个数");
    scanf("%d",&n);
    if(n>N)
    printf("个数太大,请重新分配数组的大小!\n");
    else{


    for(i=0;i<n;++i)
    {
    printf("请输入第%d个值:",i+1);
    scanf("%d",&val);
    p->a[p->last++]=val;

    //这步就相当于每次移向下一个坐标
    }
    }
    p->last--;
    printf("最后一个元素下标为%d\n",p->last);
    return p;
    }
    void traverse_list(Node p)
    {
    int i=0;
    for(i=0;i<=p->last;i++)
    printf("%3d",p->a[i]);

    printf("\n");
    return ;
    }
    void search_list(Node p,int val)
    {
    int i;
    for(i=0;i<=p->last;i++)//此时我用的下标。也可以用顺序表的长度遍历查找
    if(p->a[i]==val)
    break;
    if(i>p->last)
    printf("不能找到这个值\n");
    return ;

    }
    void insert_list(Node p,int postion,int val1)//首先要判断是否表满
    { //判断插入的位置是否合法
    int i; //然后就插入
    if(p->last+1==N) //
    printf("表满了!\n");
    if(postion<1||postion>p->last+2)//是比表长的1大,失败
    printf("插入位置不合法\n");

    else
    {
    for(i=p->last;i>=postion-1;i--)//2
    p->a[i+1]=p->a[i];
    }
    p->a[postion-1]=val1;
    p->last++;//插入后表长加1
    return ;
    }
    void delete_list(Node p,int postion,int* val)//判断是否表空。
    { //判断删除的位置合法?
    int i;
    if(p->last==-1)
    printf("表空!\n");
    if(postion>p->last+1||postion<1)
    printf("删除位置不合法~!\n");
    else 
    {
    for(i=postion;i<=p->last;i++)//
    {
    p->a[i-1]=p->a[i];
    }
    p->last--;
    }
    return ;
    }
    void sort_list(Node p)
    {

    int i,j,t;
    // printf("lalala%d",p->last);
    for(i=0;i<p->last;i++)
    for(j=i;j<p->last+1;j++)
    if(p->a[i]>p->a[j])
    {
    t=p->a[i];
    p->a[i]=p->a[j];
    p->a[j]=t;
    }
    return ;
    }
    展开全文
  • C语言实现链表基本操作之前说过顺序表基本操作。显然,顺序表有一个很大的缺点,就是做插入删除操作的时候,往往要做很大量的元素移动的操作。这里我们讨论另外一种线性表的表示方法——链式存储结构。由于它不...
  • 大三狗比较菜,以上代码在我的机子能...插入操作: #include <stdio.h> #define maxSize 100 typedef struct seqlist { int data[maxSize]; int length; }seqlist; int insertElem(seqlist *s, int p...
  • 实现了使用C语言完成顺序表的插入,排序(冒泡排序),删除。 #define maxSize 100 ... //顺序表基本操作 void CreatSqlist(Sqlist *L); void OutputSqlist(Sqlist *L); void insertElem(Sqlist *L,int x);\
  • c语言顺序表的实现与基本操作

    千次阅读 2016-09-09 00:04:00
    顺序表 定义:如图所示顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。   顺序表的特性: 1.长度固定; 2.存储空间是连续的; 3.要在顺序表中插入或...
  • C语言顺序表的12个基本操作(增删改查等)

    千次阅读 多人点赞 2020-03-20 17:19:21
    总共12大操作 初始化InitList(*L); //构造空线性表L 销毁DestoryList(*L); //销毁线性表L 清空ClearList(*L); //清空线性表L 判空ListEmpty(L); //判断线性表是否为空 求长Length(L); //求...
  • 采用c语言 写的数据结构 中的顺序表基本操作,包括插入删除查询
  • C语言实现顺序表的创建及基本操作

    千次阅读 多人点赞 2020-03-21 18:06:06
    今天主要是分享一下我在学习数据结构的顺序表时实现的一些基本操作,以及学习过程当中遇到的一些问题。我觉得学习这一部分内容的时候,除了要掌握基本操作方法的编写,还要学会对方法进行**实例化**。由于课本上这一...
  • 顺序表基本操作 C语言实现 数据结构实验
  • 数据结构顺序表操作#include #include #include #define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ElemType *elem;int length;int listsize;}sqlist;...
  • 线性表、顺序表基本操作的编程实现 二、实验要求 线性表、顺序表基本操作的编程实现,掌握线性表、顺序表的建立、遍历、插入、删除、读取等基本操作的编程实现,也可以进一步编程实现逆序等操作,存储结构可以采用...
  • 数据结构—顺序表基本操作c语言代码)

    万次阅读 多人点赞 2018-04-21 17:23:31
    创建一个静态的顺序表存放整数,大小为10,完成以下的操作 1.输入6个整数,打印出顺序表的内容,并显示表中剩余空间的个数 2.在顺序表的第三个位置处插入元素0,打印出表中的内容,并显示空间中剩余的个数 3.再试图...
  • ####顺序表操作,这里先引入头文件 #include<stdio.h> #define MAXSIZE 100 typedef int DataType; typedef struct{ DataType data[MAXSIZE]; int length; }SqList; ######初始化顺序表 只需要让length =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 67,444
精华内容 26,977
关键字:

c语言顺序表基本操作

c语言 订阅