精华内容
下载资源
问答
  • C语言建立顺序表,实现插入、删除、减、并、去重等操作 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define INIT_SIZE 20 #define INC 5 typedef int ElemType; typedef struct...

    C语言建立顺序表,实现插入、删除、减、并、去重等操作

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #define INIT_SIZE 20
    #define INC 5
    typedef int ElemType;
    typedef struct
    {
        ElemType *data;//存储数据
        int len;//当前存储数据长度
        int size;//最大存储数据长度,容量
    }List;
    //建立
    int createList(List *L)
    {
        L->data = (ElemType *) malloc(INIT_SIZE * sizeof(ElemType));
        if(!L->data) return 0;
        L->len = 0;//初始长度为0
        L->size = INIT_SIZE;//初始容量为INIT_SIZE(20)
        return 1;
    }
    //按位置插入
    int insertListPos(List *L, int pos, ElemType e)
    {
        if(pos < 1 || pos > L->len+1) return 0;//插入位置错误
        if(L->len >= L->size)
        {
            L->data = (ElemType *) realloc(L->data, (L->size + INC) * sizeof(ElemType));//申请空间
            if(!L->data) return 0;
            L->size += INC;//改变容量
        }
        int i;
        for(i = L->len-1; i >= pos-1; i --)
        {
            L->data[i+1] = L->data[i];//依次后移
        }
        L->data[pos-1] = e;//将e插入空位
        L->len ++;//长度增加1
        return 1;
    }
    //按顺序插入,保持有序
    int insertListSort(List *L, ElemType e)
    {
        if(L->len >= L->size)
        {
            L->data = (ElemType *) realloc(L->data, (L->size + INC) * sizeof(ElemType));//申请空间
            if(!L->data) return 0;
            L->size += INC;//改变容量
        }
        int i;
        for(i = L->len-1; i >= 0; i --)
        {
            if(e < L->data[i])
            {
                L->data[i+1] = L->data[i];//依次后移
            }
            else break;
        }
        L->data[i+1] = e;//将e插入空位
        L->len ++;//长度增加1
        return 1;
    }
    //按位置删除
    int deleteList(List *L, int pos)
    {
        if(pos < 1 || pos > L->len+1) return 0;
        int i;
        for(i = pos-1; i <= L->len-1; i ++)
        {
            L->data[i] = L->data[i+1];//依次前移
        }
        L->len --;//长度减1
        return 1;
    }
    //打印
    int printList(List *L)
    {
        if(L->len == 0) return 0;//长度为0,顺序表中没有元素,不需要打印
        int i;
        for(i = 0; i < L->len; i ++)
        {
            printf("%d ", L->data[i]);
        }
        return 1;
    }
    int sub(List *A, List *B)
    {
        int i, j;
        for(i = 0; i < A->len; i ++)
        {
            for(j = 0; j < B->len; j ++)
            {
                if(A->data[i] == B->data[j])
                {
                    deleteList(A, i+1);//删除A中与B相同的元素
                    sub(A, B);//递归调用
                }
            }
        }
        return 1;
    }
    int unionSet(List *A, List *B)
    {
        int i, j, flag;
        for(i = 0; i < B->len; i ++)
        {
            flag = 0;//标志位置0
            for(j = 0; j < A->len; j ++)
            {
                if(A->data[j] == B->data[i])
                {
                    flag = 1;//标志位置1
                    break;
                }
            }
            if(!flag)  insertListSort(A, B->data[i]);//将B中不同元素添加到A中
        }
        return 1;
    }
    int single(List *A)
    {
        int i, j;
        for(i = 0;i < A->len; i ++)
        {
            for(j = i+1; j < A->len; j ++)
            {
                if(A->data[i] == A->data[j])
                {
                    deleteList(A, i+1);//删除重复元素
                    single(A);//递归调用
                }
            }
        }
        return 1;
    }
    int init(List *list1,  List *list2)
    {
        list1->len = 0;//摧毁顺序表
        list2->len = 0;
        int i;
        for(i = 0;i < 10;i ++)
        {
            insertListSort(list1, i*3);
            insertListSort(list2, i*6);
        }
        return 1;
    }
    int main()
    {
        List list1, list2;//定义两个顺序表
        ElemType e;
        createList(&list1);
        createList(&list2);
        init(&list1, &list2);
        printf("\nlist1 : ");
        printList(&list1);
        printf("\nlist2 : ");
        printList(&list2);
        printf("\n演示1 : \n将元素插入list1,并保持有序:");
        printf("请输入插入元素:");
        scanf("%d", &e);
        insertListSort(&list1, e);
        printList(&list1);
        init(&list1, &list2);
        printf("\n演示2 :\n list1 - list2(将list1中和list2相同的元素去掉):");
        sub(&list1, &list2);
        printList(&list1);
        init(&list1, &list2);
        printf("\n演示3 :\n list1∪list2:");
        unionSet(&list1, &list2);
        printList(&list1);
        init(&list1, &list2);
        printf("\n演示4 :\n 去除list1中重复的元素:");
        single(&list1);
        printList(&list1);
        return 0;
    }
    
    

    运行效果实例:
    在这里插入图片描述

    感谢您花时间耐心看完,希望对您有所帮助。

    展开全文
  • 建立简单顺序链表,初学者简单易懂。   #include&lt;iostream&gt; #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; using namespace std; struct student { int num; struct ...

    建立简单顺序链表,初学者简单易懂。

     

    #include<iostream>
    #include<stdio.h>
    #include<malloc.h>
    using namespace std;
    struct student
    {
        int num;
        struct student *next;
    };
    void creat_List(struct student *&head,int n)
    {
        int i;
        student *s,*L;
        head = (student *)malloc(sizeof(student));
        L = head;
        for(i=0;i<n;i++)
        {
            s = (student *)malloc(sizeof(student));
            scanf("%d",&s->num);
            L->next = s;
            L = s;
        }
        L->next=NULL;
    }
    void Print_List(struct student *&head)
    {
        student *L;
        L=head->next;
        while(L!=NULL)
        {
            printf("%d ",L->num);
            L=L->next;
        }
    }
    int main()
    {
        int i,n;
        student *head;
        scanf("%d",&n);
        creat_List(head,n);
        Print_List(head);
        free(head);
        return 0;
    }
    

    Sample:

    5

    1 4 2 6 9

    Output:

    5

    1 4 2 6 9

    1 4 2 6 9

     

     

    展开全文
  • 顺序表是线性表中的一种重要的数据结构,也是最基础的数据结构,所以他不仅是学习中的重点,也是应用开发非常常用的一种数据结构。这篇文章介绍如何利用C语言实现顺序表
  • 主要介绍了C语言实现顺序表基本操作汇总,对学习数据结构的朋友有一定的借鉴价值,需要的朋友可以参考下
  • C语言实现顺序表

    万次阅读 多人点赞 2019-03-31 19:10:14
    c语言实现顺序表 线性表是最简单的数据结构,而顺序表又是最简单的线性表,其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素,比如我们常用的一位数组,下面代码实现了顺序表的定义以及基本操作。 ...

    c语言实现顺序表

    线性表是最简单的数据结构,而顺序表又是最简单的线性表,其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素,比如我们常用的一维数组,下面代码实现了顺序表的定义以及基本操作。

    编译环境:vs2017。

    运行试例:在这里插入图片描述
    贴代码如下:

    #include "stdio.h"
    #include "windows.h"
    #include "stdlib.h"
    
    #define MAXSIZE 20//顺序表最大长度
    
    /*定义顺序表*/
    typedef struct {
    	int data[MAXSIZE];
    	int length;
    }SeqList;
    
    /*初始化顺序表*/
    void InitList(SeqList *l)
    {
    	l->length = 0;
    }
    
    /*建立顺序表*/
    int CreatList(SeqList *l, int a[], int n) {
    	if (n > MAXSIZE)
    	{
    		printf("空间不够,无法建立顺序表。\n");
    		return 0;
    	}
    	for (int k = 0; k < n; k++)
    	{
    		l->data[k] = a[k];
    	}
    	l->length = n;
    	return 1;
    }
    
    /*判空操作*/
    int Empty(SeqList *l)
    {
    	if (l->length == 0)
    		return 1;
    	else
    		return 0;
    }
    
    /*求顺序表长度*/
    int Length(SeqList *l)
    {
    	return l->length;
    }
    
    /*遍历操作*/
    void PrintList(SeqList *l)
    {
    	for (int i = 0; i < l->length; i++)
    		printf("%d ", (l->data[i]));
    }
    
    /*按值查找*/
    int Locate(SeqList *l,int x)
    {
    	for (int i = 0; i < l->length; i++)
    	{
    		if (l->data[i] == x)
    		{
    			return i + 1;
    		}
    		return 0;
    
    	}
    	return 1;
    }
    
    /*按位查找*/
    int Get(SeqList *l, int x,int *ptr)
    {//若查找成功,则通过指针参数ptr返回值
    	if ( x <1 || x>l->length){
    		printf("查找位置非法,查找错误\n");
    		return 0;
    	}
    	else
    	{
    		*ptr = l->data[x];
    		return 1;
    	}
    }
    
    /*插入操作*/
    int Insert(SeqList *l, int i, int x)
    {
    	if (l->length > MAXSIZE)
    	{
    		printf("上溢错误!");
    		return 0;
    	}
    	if (i<1 || i>l->length)
    	{
    		printf("插入位置错误!");
    		return 0;
    	}
    	for (int k = l->length; k > i; k--)
    	{
    		l->data[k] = l->data[k - 1];
    	}
    	l->data[i] = x;
    	l->length++;
    	return 1;
    }
    
    /*删除操作*/
    int Delete(SeqList *l, int i, int *ptr)
    {
    	if (l->length == 0)
    	{
    		printf("发生下溢错误,即将要访问顺序表之前的地址.\n");
    		return 0;
    	}
    	if (i > l->length || i < 1)
    	{
    		printf("删除位置错误!\n");
    		return 0;
    	}
    	*ptr = l->data[i - 1];//把要删除的数据返回
    	for (int j = i; j < l->length; j++)
    	{
    		l->data[j - 1] = l->data[j];
    	}
    	l->length--;
    	return 1;
    }
    
    /*修改操作*/
    int Modify(SeqList *l, int i, int x)
    {
    	if (i > l->length || i < 1)
    	{
    		printf("位置错误!\n");
    		return 0;
    	}
    	l->data[i] = x;
    	return 1;
    }
    
    int main()
    {
    	int a[5] = {1,2,3,4,5 };
    	int  i, x;
    	SeqList list1;
    	InitList(&list1);//初始化顺序表
    	if (Empty(&list1))
    	{
    		printf("初始化顺序表成功!\n");
    	}
    	printf("给顺序表赋值:1 2 3 4 5\n遍历并输出顺序表:\n");
    	CreatList(&list1,a,5 );//建立一个长度为5的线性表
    	PrintList(&list1);//遍历输出此顺序表
    	printf("\n在第三位后插入一个100:\n");
    	Insert(&list1, 3, 100);
    	PrintList(&list1);
    	if (Modify(&list1, 3, 50) == 1) {
    		printf("\n把第三位改成50\n");
    		PrintList(&list1);
    	}
    	if (Delete(&list1, 4, &x) == 1) {
    		printf("\n把第四位删除,删除的值是%d\n",x);
    		PrintList(&list1);
    	}
    	system("pause");
    	return 0; 
    }
    

    水平有限,有错希望各位能不吝指出。

    展开全文
  • 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语言创建顺序表

    千次阅读 多人点赞 2019-09-24 17:02:55
    C语言顺序表 C语言顺序表 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define MAXSIZE 5 typedef char ElemType ; //声明顺序表的结构体类型 typedef struct{ ElemType...
  • 主要为大家详细介绍了C语言使用顺序表实现电话本功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 利用顺序表建立一个顺序表结构体,实现顺序表的初始化、添加数据、插入数据、删除数据、获取数据、获取元素个数、打印、遍历、排序、销毁操作。 SeqType.h文件: #include<stdbool.h> #ifndef __SEQLIST_H__ #...
  • 顺序表是用一组地址连续的存储单元依次存储数据元素的数据结构。顺序表是线性表的一种,线性表是最常用且最简单的一种数据结构,一个线性表是 n 个数据元素的有限序列。我们使用 c 语言来创建顺序表并插入元素。IDE ...
  • C语言 建立简单顺序表

    千次阅读 2019-07-23 10:09:25
    #include<stdio.h> #include<stdbool.h> #include<stdlib.h> #define TYPE int //设计数据结构 typedef struct Array { TYPE* base; //数组首地址 size_t size;...Array* create_arra...
  • //顺序表建立 void creat_list ( Sqlist & L ) { int n , i ; printf ( "请输入顺序表元素的个数:" ) ; scanf ( "%d" , & n ) ; for ( i = 0 ; i < n ; i ++ ) { printf ...
  • C语言实现顺序链表

    千次阅读 2017-09-07 20:56:57
    刚上完数据结构课,链表这一块的知识居然忘记了,也上博客看了看别人写的代码,我则是根据他们的代码写了一些代码。话不多说直接上代码。...//顺序链表的创建 struct Node { EmleType data; struct Node * nex
  • 数据结构——C语言实现顺序表

    千次阅读 2019-09-11 23:03:34
    数据结构——C语言实现顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下顺序表是以数组为基础,结构体为框架来实现的。数组存储。在数组上完成数据的增删查改,而结构体中包含...
  • C语言中实现顺序表的设计与实现,为以后建立表打下基础
  • 顺序表: int findMax(seqlist* s) { int index = 0, max = s->data[0]; for (int i = 0; i < s->length; i++) { if (max < s->data[i]) { index = i; max = s->data[i]; } } ...
  • C语言实现顺序表(顺序存储结构)

    千次阅读 2020-01-13 16:48:04
    顺序表(顺序存储结构)及初始化过程详解 顺序表,全名顺序存储结构,是线性表的一种。通过《线性表》一节的学习我们知道,线性表用于存储逻辑关系为“一对一”的数据,顺序表自然也不例外。 不仅如此,顺序表对...
  • C语言创建顺序表并插入元素 详细注释

    万次阅读 多人点赞 2018-04-22 18:03:22
    顺序表是用一组地址连续的存储单元依次存储数据元素的数据结构。顺序表是线性表的一种,线性表是最常用且最简单的一种数据结构,一个线性表是 n 个数据元素的有限序列。我们使用 c 语言来创建顺序表并插入元素。IDE ...
  • C语言实现顺序表增删查改操作

    千次阅读 2017-04-10 17:06:03
    C语言实现顺序表增删查改操作线性表是最常用且最简单的一种数据结构。线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。结构如下图图片来自百度 为了描述顺序表,我们声明一个结构,如下:...
  • C语言使用顺序表实现对学生信息的管理系统

    万次阅读 多人点赞 2018-01-29 18:25:28
    C语言使用顺序表实现对学生信息的管理系统 代码功能 1、使用顺序表实现学生名册管理程序,名册中的每条记录包括学号、姓名、联系电话等项。 2、实现数字化菜单管理:学生名册的建立、记录的添加、查找、删除和...
  • C语言实现顺序表的基本操作

    万次阅读 多人点赞 2016-09-12 09:06:36
    数据结构老师给了几个接口,叫我们自己去实现顺序表的功能,感想就是顺序表实现起来比链表容易,但是还是要花费挺长的时间来构思,这一次的收获还是挺多的。
  • C语言实现顺序表的初始化、增删查改基本功能引言定义原理实现过程及结果代码运行结果总结 引言 定义 顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表,这个表的大小为N;并且,我们称大小为0的表为空表。 ...
  • c语言实现顺序表各个功能操作函数

    千次阅读 2018-05-25 17:46:02
    c语言实现顺序表的操作函数 首先,一个顺序表先要用结构体定义 typedef struct Seqlist{ Datatype array[MAX_SIZE]; size_t Size; }Seqlist,*psl; 然后要被初始化,这里用memset来初始化 memset(psl-&...
  • 在数据结构的开始,首要讲的是顺序表顺序表分为静态顺序表和动态顺序表1、静态顺序表个人认为,静态顺序表和数组并不二样,静态的一张表,首要必须确定元素的个数,比如这样写typedef MaxSoze 10 ;int a[MaxSize];...
  • C语言实现顺序表的创建及基本操作

    千次阅读 多人点赞 2020-03-21 18:06:06
    今天主要是分享一下我在学习数据结构的顺序表时实现的一些基本操作,以及学习过程当中遇到的一些问题。我觉得学习这一部分内容的时候,除了要掌握基本操作方法的编写,还要学会对方法进行**实例化**。由于课本上这一...
  • c语言实现顺序表(详细代码)

    千次阅读 2020-06-12 23:47:57
    #define MaxSize 100 //顺序表的最大长度 typedef struct{ ElemType *data; //存储空间基址 int length; }SqList; //初始化顺序表,创建一个空表 void InitList(SqList *L) { L->data = (ElemType *
  • 采用c语言 写的数据结构 中的顺序表的基本操作,包括插入删除查询
  • C语言实现顺序表的插入、删除、查找、遍历等基本操作 /*编写完整的程序实现顺序的建立、查找、插入、删除等基本操作*/ #include #include #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define OK 1 #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,974
精华内容 18,389
关键字:

c语言建立顺序表

c语言 订阅