精华内容
下载资源
问答
  • 通讯录:用顺序表存储c语言控制台程序,基于visual编程,有增删改查,排序,保存等功能
  • C语言实现动态顺序表的实现代码顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表顺序表是将表中的结点...

    C语言实现动态顺序表的实现代码

    顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

    静态实现:结构体内部只需两个成员,其中一个为固定大小(MAX)的数组,用来存放我们的数据。数组大小我们可以通过在头文件中改变MAX的值来改变。

    动态实现:在内存中开辟一块空间,可以随我们数据数量的增多来扩容。

    来看看动态的顺序表实现:

    1.seqlist.h

    #define _CRT_SECURE_NO_WARNINGS 1

    #ifndef __SEQLIST_H__

    #define __SEQLIST_H__

    #include

    #include

    #include

    #include

    typedef int DataType;

    #define DEFAULT_SZ 3

    #define INC_SZ 2

    typedef struct SeqList

    {

    DataType *data;

    int sz;

    int capacity;

    }SeqList,*pSeqList;

    void InitSeqList(pSeqList pList);

    void PushBack(pSeqList pList,DataType d);

    void PopBack(pSeqList pList);

    void PushFront(pSeqList pList, DataType d);

    void PopFront(pSeqList pList);

    int Find(pSeqList pList, DataType d);

    void Remove(pSeqList pList, DataType d);

    void RemoveAll(pSeqList pList, DataType d);

    void BubbleSort(pSeqList pList);

    int BinarySearch(pSeqList pList, DataType d);

    void PrintfSeqList(pSeqList pList);

    void Insert(pSeqList pList, int pos, DataType d);

    void ReverseList(pSeqList pList);

    void DestroySeqList(pSeqList pList);

    #endif//__SEQLIST_H__

    2.seqlist.c

    #define _CRT_SECURE_NO_WARNINGS 1

    #include "seqlist.h"

    void InitSeqList(pSeqList pList)

    {

    pList->sz = 0;

    pList->data = (DataType*)malloc(sizeof(DataType)*DEFAULT_SZ);

    if (pList->data == NULL)

    {

    perror("malloc");

    return;

    }

    memset(pList->data, 0, sizeof(DataType)*DEFAULT_SZ);

    }

    void CheckCapacity(pSeqList pList)

    {

    assert(pList);

    if (pList->sz == pList->capacity)

    {

    DataType*ret = (DataType*)realloc(pList->data, sizeof(DataType)*(pList->capacity + INC_SZ));

    if (ret == NULL)

    {

    perror("realloc");

    }

    pList->data = ret;

    pList->capacity += INC_SZ;

    }

    }

    void PushBack(pSeqList pList, DataType d)

    {

    assert(pList);

    if (pList->sz == pList->capacity)

    {

    CheckCapacity(pList);

    }

    pList->data[pList->sz] = d;

    pList->sz++;

    }

    void PopBack(pSeqList pList)

    {

    int i = 0;

    assert(pList);

    if (pList->sz == 0)

    {

    printf("顺序表为空:

    return;

    }

    pList->sz--;

    }

    void PushFront(pSeqList pList, DataType d)

    {

    int i = 0;

    assert(pList);

    if (pList->sz == pList->capacity)

    {

    CheckCapacity(pList);

    }

    for (i = pList->sz; i >= 1; i--)

    {

    pList->data[i] = pList->data[i - 1];

    }

    pList->data[0] = d;

    pList->sz++;

    }

    void PopFront(pSeqList pList)

    {

    int i = 0;

    assert(pList);

    for (i = 0; i < pList->sz; i++)

    {

    pList->data[i] = pList->data[i + 1];

    }

    pList->sz--;

    }

    int Find(pSeqList pList, DataType d)

    {

    int i = 0;

    assert(pList);

    while (i < pList->sz)

    {

    if (pList->data[i] == d)

    {

    return i;

    }

    else

    {

    i++;

    }

    }

    return -1;

    }

    void Remove(pSeqList pList, DataType d)

    {

    int i = 0;

    int pos = 0;

    assert(pList);

    while (pList->data[pos=Find(pList,d)]==d)

    {

    for (i = pos; i < pList->sz-1; i++)

    {

    pList->data[i] = pList->data[i + 1];

    }

    pList->sz--;

    }

    }

    void RemoveAll(pSeqList pList, DataType d)

    {

    int i = 0;

    int pos = 0;

    assert(pList);

    while ((pos = Find(pList, d)) != -1)

    {

    for (i = pos; i < pList->sz - 1; i++)

    {

    pList->data[i] = pList->data[i + 1];

    }

    pList->sz--;

    }

    }

    void BubbleSort(pSeqList pList)

    {

    int i = 0;

    assert(pList);

    for (i = 0; i < pList->sz - 1; i++)

    {

    int j = 0;

    for (j = 0; j < pList->sz - i - 1; j++)

    {

    if (pList->data[j]>pList->data[j + 1])

    {

    DataType tmp = pList->data[j];

    pList->data[j] = pList->data[j + 1];

    pList->data[j + 1] = tmp;

    }

    }

    }

    }

    int BinarySearch(pSeqList pList, DataType d)

    {

    int left = 0;

    int right = pList->sz - 1;

    assert(pList);

    while (left <= right)

    {

    int mid = left - ((left - right) >> 1);

    if (d > pList->data[mid])

    {

    left = mid + 1;

    }

    else if (d < pList->data[mid])

    {

    right = mid - 1;

    }

    else

    return mid;

    }

    return -1;

    }

    void PrintfSeqList(pSeqList pList)

    {

    int i = 0;

    for (i = 0; i < pList->sz; i++)

    {

    printf("%d ", pList->data[i]);

    }

    }

    void Insert(pSeqList pList, int pos, DataType d)

    {

    int i = 0;

    if (pList->sz == pList->capacity)

    {

    CheckCapacity(pList);

    }

    for (i = pList->sz - 1; i >= pos; i--)

    {

    pList->data[i + 1] = pList->data[i];

    }

    pList->data[pos] = d;

    pList->sz++;

    }

    void ReverseList(pSeqList pList)

    {

    int left = 0;

    int right = pList->sz - 1;

    assert(pList);

    while (left < right)

    {

    DataType tmp = pList->data[left];

    pList->data[left] = pList->data[right];

    pList->data[right] = tmp;

    left++;

    right--;

    }

    }

    void DestroySeqList(pSeqList pList)

    {

    free(pList->data);

    pList->data = NULL;

    }

    3.test.c

    #define _CRT_SECURE_NO_WARNINGS 1

    #include "seqlist.h"

    //void Test()

    //{

    // SeqList *List;

    // InitSeqList(&List);

    // PushBack(&List, 1);

    // PushBack(&List, 2);

    // PushBack(&List, 3);

    // PushBack(&List, 4);

    // PushBack(&List, 5);

    // PopBack(&List);

    // printf("%d ", Find(&List, 2));

    // PrintfSeqList(&List);

    //}

    void Test2()

    {

    SeqList List;

    InitSeqList(&List);

    PushBack(&List, 1);

    PushBack(&List, 2);

    PushBack(&List, 3);

    PushBack(&List, 4);

    PushBack(&List, 5);

    PushFront(&List, 5);

    PushFront(&List, 2);

    PushFront(&List, 3);

    //PopFront(&List);

    RemoveAll(&List, 5);

    //BubbleSort(&List);

    //BinarySearch(&List, 3);

    PrintfSeqList(&List);

    }

    int main()

    {

    Test2();

    system("pause\n");

    return 0;

    }

    以上就是动态实现顺序表的实例,如有疑问请留言或者到本站社区交流讨论,感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • 换句话说,顺序表中插入元素问题也就等同于讨论如何向数组中插入数据。因此,顺序表中插入数据元素,无非三种情况:在表头插入;在表的中间某个位置插入;直接尾随顺序表,作为表的最后一个元素;无论在顺序表的什么...

    换句话说,顺序表中插入元素问题也就等同于讨论如何向数组中插入数据。

    因此,顺序表中插入数据元素,无非三种情况:

    在表头插入;

    在表的中间某个位置插入;

    直接尾随顺序表,作为表的最后一个元素;

    无论在顺序表的什么位置插入数据元素,解决办法都是:找到要插入的位置,将后续数据元素整体向后移动一个位置,最后直接在腾出来的位置上插入指定的数据元素。

    顺序表插入数据操作的 C 语言实现代码为:

    //插入函数,其中,elem为插入的元素,add为插入到顺序表的位置table addTable(table t,int elem,int add)

    {

    //判断插入本身是否存在问题(如果插入元素位置比整张表的长度+1还大(如果相等,是尾随的情况),

    //或者插入的位置本身不存在,程序作为提示并自动退出)

    if (add>t.length+1||add<1) {

    printf("插入位置有问题");

    return t;

    }

    //做插入操作时,首先需要看顺序表是否有多余的存储空间提供给插入的元素,如果没有,需要申请

    if (t.length==t.size) {

    t.head=(int *)realloc(t.head, (t.size+1)*sizeof(int));

    if (!t.head) {

    printf("存储分配失败");

    return t;

    }

    t.size+=1;

    }

    //插入操作,需要将从插入位置开始的后续元素,逐个后移

    for (int i=t.length-1; i>=add-1; i--) {

    t.head[i+1]=t.head[i];

    }

    //后移完成后,直接将所需插入元素,添加到顺序表的相应位置

    t.head[add-1]=elem;

    //由于添加了元素,所以长度+1

    t.length++;

    return t;

    }

    注意,在此程序中,当数组存储空间不足时,使用realloc函数每次额外多申请 1 个 int 型的存储空间,这么做还不是最优。最好的办法就是每次发现空间不够时,多申请几个内存空间,这么做的好处是:在后续做插入操作过程中不需要每次都运行 realloc 函数,提高了程序的运行效率。

    完整程序如下(可运行):

    #include

    #include

    #define Size 4

    typedef struct Table{

    int * head;

    int length;

    int size;

    }table;

    table initTable(){

    table t;

    t.head=(int*)malloc(Size*sizeof(int));

    if (!t.head)

    {

    printf("初始化失败");

    exit(0);

    }

    t.length=0;

    t.size=Size;

    return t;

    }

    table addTable(table t,int elem,int add)

    {

    if (add>t.length+1||add<1) {

    printf("插入位置有问题");

    return t;

    }

    if (t.length>=t.size) {

    t.head=(int *)realloc(t.head, (t.size+1)*sizeof(int));

    if (!t.head) {

    printf("存储分配失败");

    }

    t.size+=1;

    }

    for (int i=t.length-1; i>=add-1; i--) {

    t.head[i+1]=t.head[i];

    }

    t.head[add-1]=elem;

    t.length++;

    return t;

    }

    void displayTable(table t){

    for (int i=0;i

    printf("%d",t.head[i]);

    }

    printf("\n");

    }

    int main(){

    table t1=initTable();

    for (int i=1; i<=Size; i++) {

    t1.head[i-1]=i;

    t1.length++;

    }

    printf("原顺序表:\n");

    displayTable(t1);

    printf("在第2的位置插入元素5:\n");

    t1=addTable(t1, 5, 2);

    displayTable(t1);

    return 0;

    }

    输出结果:

    原顺序表:

    1234

    在第2的位置插入元素5:

    15234

    展开全文
  • 顺序表操作集C语言详解版完整可编译 顺序表操作集C语言源代码 #include <stdio.h> #include <stdlib.h> #define MAX_SIZE 30 //对MAXSIZE进行宏定义,表示顺序表申请空间的大小 typedef int ElementType...

    顺序表操作集C语言详解版完整可编译

    顺序表操作集C语言源代码

    #include <stdio.h>
    #include <stdlib.h>
    #define MAX_SIZE 30   //对MAXSIZE进行宏定义,表示顺序表申请空间的大小
    typedef int ElementType;
    typedef struct SqList {
    	ElementType * Data;//声明了一个名为Data的长度不确定的数组,也叫“动态数组”
    	int length;//记录当前顺序表的长度
    	int size;//记录顺序表分配的存储容量
    } List;
    
    List InitSqList();
    void ShowList(List L);
    List Insert(List L,ElementType elem,int pos);
    List Delete(List L, int pos);
    int Find(List L, ElementType elem);
    List Amend(List L, ElementType elem, ElementType newElem);
    void ToN();
    
    int main() {
    	List L = InitSqList();
    	ElementType X,e,Elem,newElem;
    	int choice = 99,i = 0,p;
    	printf("*********顺序表*********\n");
    	printf("1.创建\n2.查找\n3.插入\n4.删除\n5.输出\n6.求表长\n7.修改\n8.10进制转N进制\n0.安全退出程序\n");
    	while (choice != 0) {
    		printf("\t请输入你的选择(数字):");
    		scanf("%d",&choice);
    		fflush(stdin);
    		switch (choice) {
    			case 0:
    				printf("\n安全退出程序...");
    				exit(0);
    			case 1:
    				printf("\n创建线性表------请输入线性表元素(以-999结束输入):");
    				while (1) {
    					scanf("%d",&e);
    					if (e == -999) break;
    					L.Data[i++] = e;
    					L.length++;
    					if (L.length > L.size) {
    						printf("超出MAX_SIZE");
    						break;
    					}
    				}
    				break;
    			case 2:
    				printf("\n请输入要查找的元素X:");
    				scanf("%d", &X);
    				p = Find(L, X);
    				if ( p == -1 ) printf("查找错误: %d 不是此线性表中元素.\n", X);
    				else printf("%d 在 %d 处 .\n", X, p);
    				break;
    			case 3:
    				printf("\n请输入要插入的元素X和要插入的位置p:");
    				scanf("%d %d",&X,&p);
    				L = Insert(L, X, p);
    				break;
    			case 4:
    				printf("\n请输入要删除的位置p:");
    				scanf("%d", &p);
    				L = Delete(L, p);
    				break;
    			case 5:
    				ShowList(L);
    				break;
    			case 6:
    				printf(" 表长为%d",L.length);
    				break;
    			case 7:
    				printf("\n请输入要修改的元素和新元素:");
    				scanf("%d %d",&Elem, &newElem);
    				L = Amend(L, Elem, newElem);
    				break;
    			case 8:
    				ToN();
    				break;
    			default:
    				printf("无效选择,请确认菜单有此选项再重新输入!");
    				break;
    		}
    	}
    	return 0;
    }
    
    
    /*顺序表初始化*/
    List InitSqList() {
    	List L;
    	L.Data = (int*)malloc(MAX_SIZE * sizeof(int));//构造一个空的顺序表,动态申请存储空间
    	if (!L.Data) { //如果申请失败,作出提示并直接退出程序
    		printf("初始化失败");
    		exit(0);
    	}
    	L.length = 0;//空表的长度初始化为0
    	L.size = MAX_SIZE;//空表的初始存储空间为MAX_SIZE
    	return L;
    }
    
    //输出顺序表中元素
    void ShowList(List L) {
    	int i;
    	printf("\n线性表为:");
    	for (i = 0; i < L.length; i++) {
    		printf("%d ", L.Data[i]);
    	}
    	printf("\n");
    }
    
    //插入函数,其中,elem为插入的元素,pos为插入到顺序表的位置
    List Insert(List L,ElementType elem,int pos) {
    	int i;
    	//判断插入位置本身是否存在问题(如果插入元素位置比整张表的长度+1还大(如果相等,是尾随的情况),或者插入的位置本身不存在,程序作出提示并自动退出)
    	if (pos > L.length+1 || pos <1) {
    		printf("插入位置有问题!");
    		return L;
    	}
    	//做插入操作时,首先需要看顺序表是否有多余的存储空间提供给插入的元素,如果没有,需要申请
    	if (L.length == L.size) {
    		L.Data = (int *)realloc(L.Data,(L.size + 1) * sizeof(int));
    		if (!L.Data) {
    			printf("存储分配失败!");
    			return L;
    		}
    		L.size += 1;
    	}
    	//插入操作,需要将从插入位置开始的后续元素,逐个后移
    	for (i = L.length - 1; i >= pos - 1; i--) {
    		L.Data[i + 1] = L.Data[i];
    	}
    	//后移完成后,直接将所需插入元素,添加到顺序表的相应位置
    	L.Data[pos - 1] = elem;
    	//由于添加了元素,所以长度+1
    	L.length++;
    	return L;
    }
    
    /*删除操作*/
    List Delete(List L, int pos) {
    	int i;
    	if (pos > L.length || pos < 1) {
    		printf("被删除元素的位置有误");
    		exit(0);
    	}
    	//删除操作,需要将从删除位置开始的后续元素,逐个前移
    	for (i = pos; i < L.length; i++) {
    		L.Data[i - 1] = L.Data[i];
    	}
    	L.length--;
    	return L;
    }
    
    //查找函数,其中,elem表示要查找的数据元素的值
    int Find(List L, ElementType elem) {
    	int i;
    	for (i = 0; i < L.length; i++) {
    		if (L.Data[i] == elem) {
    			return i + 1;
    		}
    	}
    	return -1;//如果查找失败,返回-1
    }
    
    //修改函数,其中,elem为要更改的元素,newElem为新的数据元素
    List Amend(List L, ElementType elem, ElementType newElem) {
    	int pos = Find(L, elem);
    	L.Data[pos- 1] = newElem;//由于返回的是元素在顺序表中的位置,所以-1就是该元素在数组中的下标
    	return L;
    }
    
    void ToN() {
    	printf("请输入数据和要转换的进制:\n");
    	int num,n;
    	scanf("%d %d",&num,&n);
    	int a[100];
    	int k = 0;
    	while (num != 0) {
    		a[k++] = num%n;
    		num /= n;
    	}
    	int j;
    	printf("转换成%d进制为:",n);
    	for (j = k-1; j >= 0; j--) {
    		printf("%d",a[j]);
    	}
    	return;
    }
    

    顺序表操作集运行结果

    在这里插入图片描述

    展开全文
  • 3.2 C语言实现顺序表 3.3 测试结果 1.顺序表的定义    将表中元素一个接一个的存入一组连续的存储单元中,这种存储结构是顺序结构,采用顺序存储结构的线性表简称为“ 顺序表”。    顺序表存储特点是...
     
    

    1.顺序表的定义

       将表中元素一个接一个的存入一组连续的存储单元中,这种存储结构是顺序结构,采用顺序存储结构的线性表简称为“ 顺序表”。
       顺序表的存储特点是:只要确定了起始位置,表中任一元素的地址都通过下列公式得到:

    Loc(ai)=Loc(a1)+(i1)L,1in L o c ( a i ) = L o c ( a 1 ) + ( i − 1 ) ∗ L , 1 ≤ i ≤ n
    其中,L是元素占用存储单元的长度。

    2.顺序表的基本操作

    (1)初始化:建立一个空的顺序表;
    (2)新建:新建一个顺序表;
    (3)合并顺序表:将两个顺序表合并,并去掉重复元素;
    (4)按元素查找:查找顺序表中是否含有指定元素;
    (5)按位置查找:查找指定位置的元素;
    (6)求顺序表的长度:计算顺序表的元素个数;
    (7)指定位置插入:在指定位置插入元素;
    (8)删除元素:删除指定位置的元素;
    (9)判空:判断是否是空的顺序表;
    (10)清空顺序表;
    (11)显示:显示当前顺序表的所有数据。

    3.顺序表的编程实现

    • 3.1 C++实现顺序表

    (1)顺序表的头文件 sequencelist.h

    #ifndef SEQUENCELIST_H
    #define SEQUENCELIST_H
    
    #define MAXSIZE 20//最大存储容量
    typedef int ElemType;
    
    class SqList
    {
    public:
        SqList();//
        SqList(ElemType elems[],int n);//有参构造器
        ~SqList();//
        bool CreatList();//新建一个顺序表
        bool UnionList(SqList L1,SqList L2);
        int LocateElem(ElemType e);//按元素查找:成功则返回元素的序号(从1开始),失败则返回0
        int ListLength();//顺序表的长度
        bool GetElem(int i, ElemType& e);//查找第i个位置的元素
        bool ListInsert(int i,ElemType e);//在第i个位置插入元素
        bool ListDelete(int i,ElemType& e);//删除第i个位置的元素
        bool ListEmpty();//判空
        void clearList();//清空顺序表
        void display();//显示当前的顺序表
    
    private:
        ElemType data[MAXSIZE];//下标从0开始,但是对线性表的操作中的下标从1开始:第1个元素其实就是下标为0的元素
        int length;
    };
    
    #endif // SEQUENCELIST_H

    (2)顺序表的源文件 sequencelist.cpp

    #include "sequencelist.h"
    #include <iostream>
    using namespace std;
    
    SqList::SqList()//初始化
    {
        length=0;//
    }
    
    SqList::SqList(ElemType elems[],int n)//有参构造器
    {
        if(n>MAXSIZE)
        {
            cout<<"传入的顺序表长度超出最大范围,只接收了前"<<MAXSIZE<<"个元素"<<endl;
            length=MAXSIZE;
        }
        else
            length=n;//
    
        for(int i=0;i<length;i++)
            data[i]=elems[i];
    }
    
    SqList::~SqList()
    {
    
    }
    
    bool SqList::CreatList()
    {
    
        cout<<"插入多少个元素(0-20)?"<<endl;
        cin>>length;
        if(length<0||length>MAXSIZE)
        {
            length=0;
            return false;
        }
        for(int i=1;i<=length;i++)
        {
    //        cout<<"请输入顺序线性表的第"<<i<<"个元素:";
    //        cin>>L->data[i-1];
            data[i-1]=i;
        }
        return true;
    }
    
    bool SqList::UnionList(SqList L1,SqList L2)
    {
        int i,j;
        for(i=0;i<L1.length;i++)
        {
            data[i]=L1.data[i];
        }
    
        for(j=0;j<L2.length;j++)
            if(L1.LocateElem(L2.data[j])==0)
            {
                if(i>=MAXSIZE)
                    return false;
                data[i]=L2.data[j];
                i++;
            }
        length=i;
        return true;
    }
    
    int  SqList::LocateElem(ElemType e)//成功则返回元素的序号(从1开始),失败则返回0
    {
        for(int i=0;i<length;i++)
            if(data[i]==e)
                return i+1;
        return 0;
    }
    
    int  SqList::ListLength()
    {
        return length;
    }
    
    bool SqList::GetElem(int i, ElemType& e)
    {
        if(length==0 || i<1|| i>length)
            return false;
        e=data[i-1];
        return true;
    }
    
    bool SqList::ListInsert(int i,ElemType e)
    {
        if(length==MAXSIZE || i<1|| i>length+1)//线性表满,或者i的范围不在合理范围内时返回错误
            return false;
        if(i<=length)//不在表尾
        {
            //插入位置的后续元素后移一位
            for(int k=length-1;k>=i-1;k--)
                data[k+1]=data[k];// 倒序挪动位置,避免覆盖问题
        }
        data[i-1]=e;//插入元素
        length++;
        return true;
    }
    
    bool SqList::ListDelete(int i,ElemType& e)
    {
        if(length==0 || i<1|| i>length)//线性表满,或者i的范围不在合理范围内时返回错误
            return false;
        e=data[i-1];//取出元素
        if(i<=length)//不在表尾
        {
            //插入位置的后续元素前移一位
            for(int k=i-1;k<length-1;k++)
                data[k]=data[k+1];// 倒序挪动位置,避免覆盖问题
        }
        length--;
        return true;
    }
    
    bool SqList::ListEmpty()
    {
        if (length==0)
            return true;
        return false;
    }
    
    void SqList::clearList()
    {
        length=0;
    }
    
    void SqList::display()
    {
        for(int i=0;i<length;i++)
            cout<<data[i]<<"  ";
        cout<<endl;
    }

    (3)主函数 main.cpp

    #include <iostream>
    #include "sequencelist.h"
    using namespace std;
    
    int main()
    {
        SqList list;
        int num;
        ElemType elem;
        bool flag;
    
        cout<<"            1.顺序表的创建和显示"<<endl;
        if(!list.CreatList())
            cout<<"顺序表创建失败!"<<endl;
        else
            cout<<"顺序表创建成功!    "<<endl;
        //顺序表的显示
        list.display();
        cout<<endl<<endl;
    
        cout<<"            2.按元素查找"<<endl;
        num=list.LocateElem(3);
        cout<<"3是顺序表的第"<<num<<"个元素"<<endl<<endl<<endl;
    
        cout<<"            3.按位置查找"<<endl;
        list.GetElem(4,elem);
        cout<<"顺序表的第4个元素是:"<<elem<<endl<<endl<<endl;
    
        cout<<"            4.顺序表的插入"<<endl;
        if(list.ListInsert(2,10))
            cout<<"插入成功!在第2个位置插入10后:    "<<endl;
        else
            cout<<"插入失败!"<<endl;
        list.display();
        cout<<endl<<endl;
    
        cout<<"            5.删除元素"<<endl;
        list.ListDelete(5,elem);
        cout<<"删掉第5个元素:"<<elem<<endl;
        cout<<"该表的长度为:"<<list.ListLength()<<endl;
        list.display();
        cout<<endl<<endl;
    
        cout<<"            6.清空顺序表"<<endl;
        cout<<"清空顺序表前-----";
        if(!list.ListEmpty())
        {
            cout<<"当前顺序表不是空表!"<<endl;
            list.clearList();
            cout<<"清空顺序表后-----";
            if(list.ListEmpty())
                cout<<"当前顺序表是空表!"<<endl;
        }
        cout<<endl<<endl;
    
        cout<<"            7.合并顺序表"<<endl;
        ElemType elems1[8]={0,1,2,3,4,5,6,7};
        ElemType elems2[9]={5,6,7,8,9,10,11,1,12};
    
        SqList list1={elems1,8};
        SqList list2={elems2,9};
        SqList list3;
        cout<<"合并前的两个表为:"<<endl;
        list1.display();
        list2.display();
        flag=list3.UnionList(list1,list2);
        if(!flag)
            cout<<"合并后,顺序表的长度超过最大范围"<<endl;
        cout<<"该表的长度为:    "<<list3.ListLength()<<endl;
        list3.display();
        return 0;
    }
    • 3.2 C语言实现顺序表


      (1)顺序表的头文件 sequencelist.h
    #ifndef SEQUENCELIST_H
    #define SEQUENCELIST_H
    
    #define MAXSIZE 20//最大存储容量
    typedef int ElemType;
    typedef struct
    {
        ElemType data[MAXSIZE];//下标从0开始,但是对线性表的操作中的下标从1开始:第1个元素其实就是下标为0的元素
        int length;
    }SqList;
    
    typedef enum Bool
    {
        FALSE,TRUE//枚举默认值从0开始,依次加1
    }Bool;
    
    Bool CreatList(SqList* L);//)新建一个顺序表
    Bool UnionList(SqList* L1,SqList* L2,SqList* L);
    int LocateElem(SqList L,ElemType e);//成功则返回元素的序号(从1开始),失败则返回0
    int ListLength(SqList L);//顺序表的长度
    Bool GetElem(SqList L, int i, ElemType* e);//查找第i个位置的元素
    Bool ListInsert(SqList* L,int i,ElemType e);//在第i个位置插入元素
    Bool ListDelete(SqList* L,int i,ElemType* e);//删除第i个位置的元素
    Bool ListEmpty(SqList L);//判空
    void clearList(SqList* L);//清空顺序表
    void display(SqList L);//显示当前的顺序表
    #endif // SEQUENCELIST_H

    (2)顺序表的源文件 sequencelist.c

    #include "sequencelist.h"
    #include <stdio.h>
    
    Bool GetElem(SqList L, int i, ElemType* e)
    {
        if(L.length==0 || i<1|| i>L.length)
            return FALSE;
        *e=L.data[i-1];
        return TRUE;
    }
    
    Bool ListInsert(SqList* L,int i,ElemType e)
    {
        int k;
        if(L->length==MAXSIZE || i<1|| i>L->length+1)//线性表满,或者i的范围不在合理范围内时返回错误
            return FALSE;
        if(i<=L->length)//不在表尾
        {
            //插入位置的后续元素后移一位
            for(k=L->length-1;k>=i-1;k--)
                L->data[k+1]=L->data[k];// 倒序挪动位置,避免覆盖问题
        }
        L->data[i-1]=e;//插入元素
        L->length++;
        return TRUE;
    }
    
    Bool ListDelete(SqList* L,int i,ElemType* e)
    {
        int k;
        if(L->length==0 || i<1|| i>L->length)//线性表满,或者i的范围不在合理范围内时返回错误
            return FALSE;
        *e=L->data[i-1];//取出元素
        if(i<=L->length)//不在表尾
        {
            //插入位置的后续元素前移一位
            for(k=i-1;k<L->length-1;k++)
                L->data[k]=L->data[k+1];// 倒序挪动位置,避免覆盖问题
        }
        L->length--;
        return TRUE;
    }
    
    Bool CreatList(SqList* L)
    {
        int i;
        printf("插入多少个元素(0-20)?\n");
        scanf("%d",&(L->length));
        if(L->length<0||L->length>MAXSIZE)
            return FALSE;
        for(i=1;i<=L->length;i++)
        {
    //        cout<<"请输入顺序线性表的第"<<i<<"个元素:";
    //        cin>>L->data[i-1];
            L->data[i-1]=i;
        }
        return TRUE;
    }
    Bool ListEmpty(SqList L)
    {
        if (L.length==0)
            return TRUE;
        return FALSE;
    }
    
    void clearList(SqList* L)
    {
        L->length=0;
    }
    int  LocateElem(SqList L,ElemType e)//成功则返回元素的序号(从1开始),失败则返回0
    {
        int i=0;
        for(i=0;i<L.length;i++)
            if(L.data[i]==e)
                return i+1;
        return 0;
    }
    int  ListLength(SqList L)
    {
        return L.length;
    }
    
    void display(SqList L)
    {
        int i;
        for(i=0;i<L.length;i++)
            printf("%d  ",L.data[i]);
        printf("\n");
    }
    
    
    //不调用底层程序,直接编程实现顺序表合并,这种方法较为复杂
    Bool UnionList1(SqList* L1,SqList* L2,SqList* L)
    {
        int i,j,k;
        L->length=0;
        for(i=0;i<L1->length;i++)
        {
            L->data[i]=L1->data[i];
        }
    
        for(j=0;j<L2->length;j++)
        {
            for(k=0;k<L1->length;k++)
            {
               if(L2->data[j]==L1->data[k])
                   break;
            }
    
            if(k==L1->length)
            {
                if(i>=MAXSIZE)
                    return FALSE;
                L->data[i]=L2->data[j];
                i++;
            }
        }
        L->length=i;
        return TRUE;
    }
    
    //调用底层程序来查找元素,减轻了工作量
    Bool UnionList(SqList* L1,SqList* L2,SqList* L)
    {
        int i,j;
        L->length=0;
        for(i=0;i<L1->length;i++)
        {
            L->data[i]=L1->data[i];
        }
    
        for(j=0;j<L2->length;j++)
            if(LocateElem(*L1,L2->data[j])==0)
            {
                if(i>=MAXSIZE)
                    return FALSE;
                L->data[i]=L2->data[j];
                i++;
            }
    
        L->length=i;
        return TRUE;
    }

    (3)主函数 main.c

    #include <stdio.h>
    #include "sequencelist.h"
    
    int main()
    {
        SqList list;
        int num;
        ElemType elem;
        Bool flag;
    
        printf("            1.顺序表的创建和显示\n");
        if(!CreatList(&list))
            printf("顺序表创建失败!\n");
        else
            printf("顺序表创建成功!\n    ");
        //顺序表的显示
        display(list);
        printf("\n\n");
    
        printf("            2.按元素查找\n");
        num=LocateElem(list,3);
        printf("3是顺序表的第%d个元素",num);
        printf("\n\n\n");
    
        printf("            3.按位置查找\n");
        GetElem(list,4,&elem);
        printf("顺序表的第4个元素是%d",elem);
        printf("\n\n\n");
    
        printf("            4.顺序表的插入\n");
        ListInsert(&list,2,10);
        printf("在第2个位置插入10后:\n    ");
        display(list);
        printf("\n\n");
    
        printf("            5.删除元素\n");
        ListDelete(&list,5,&elem);
        printf("删掉第5个元素:%d\n",elem);
        printf("该表的长度为:%d\n    ",ListLength(list));
        display(list);
        printf("\n\n");
    
        printf("            6.清空顺序表\n");
        printf("清空顺序表前-----");
        if(!ListEmpty(list))
        {
            printf("当前顺序表不是空表!\n");
            clearList(&list);
            printf("清空顺序表后-----");
            if(ListEmpty(list))
                printf("当前顺序表是空表!\n");
        }
        printf("\n\n");
    
        printf("            7.合并顺序表\n");
        SqList list1={{0,1,2,3,4,5,6,7},8},list2={{5,6,7,8,9,10,11,1,12},9},list3;
        flag=UnionList(&list1,&list2,&list3);
        if(!flag)
            printf("合并后,顺序表的长度超过最大范围");
        printf("该表的长度为:%d\n    ",ListLength(list3));
        display(list3);
        printf("\n\n");
        return 0;
    }
    • 3.3 测试结果


      这里写图片描述
    展开全文
  • 顺序表详解(C语言版)

    千次阅读 多人点赞 2020-09-27 22:44:24
    本文介绍了顺序表的定义和常见操作并使用C语言代码对其进行实现。
  • 数据结构-顺序表详解(C语言版)

    多人点赞 热门讨论 2021-08-04 09:11:13
    顺序表动态存储 如果空间不够,则进行增容。 顺序表的实现(C语言版本) 顺序表功能: 各功能的实现: 零:头文件部分 #pragma once #include<stdio.h> #include <assert.h> #include <...
  • 顺序表的静态存储c语言实现

    千次阅读 2016-12-05 18:54:58
    顺序表的静态存储: 通过数组保存数据,程序分2个源文件和一个头文件: sxb.h包含程序需要用到的函数原型和结构声明,一般类型定义 test.c用来测试程序 sxb.c包含用到的函数实现 test.c: /* 顺序表 */ #include ...
  • *描述: 线性表(动态) *函数: Status initList_Sq(&L); 初始化操作 Status ListInsert_Sq(&L,i,b); 插入操作 ElemType GetElem(&L,i); 按位取元素 ElemType ListDelete(&L,i); 删除 Sq_List ...
  • 2.掌握顺序表存储结构; 3.掌握顺序表的创建、查找、插入、删除的实现方法; 实验内容 问题描述 在给出一组初始数据的情况下,实现顺序表的定义、创建、查找、插入、删除。 算法 顺序表的定义:一维数组、最大长度...
  • // 2 长度 记录当前顺序表元素个数 int size; // 3 大小 记录当前的顺序表最大长度 }Table; // 创建一个顺序表 // 参数: 初始长度 Table CreatTable(int SIZE); // 给所有元素初始值 // 参数: 表指针 (表以创建...
  • 顺序表--------------线性表的第一个儿子这个儿子的结构体定义:typedef int ElemType;//取别名typedef struct link{ElemType * head;//head是一个数组指针,不太清楚的同学,可以百度一下ElemType length;ElemType ...
  • C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表顺序表是将表中的结点...
  • 数据结构C语言实现动态顺序表

    多人点赞 热门讨论 2021-08-11 16:38:41
    动态顺序表C语言实现: 正文开始@Assassin 目录:动态顺序表C语言实现:==什么是顺序表?==1. 定义顺序表结构体:2. 初始化顺序表:3. 销毁顺序表:4. 打印顺序表:5. 判断容量+扩容:6. 头插数据:7. 尾插数据:...
  • (1)设置有序顺序表C的表长,即C.listsize = C.lenghth = A.length+B.length。 (2)设置A.elem、B.elem、C.elem的下标分别为i,j,k,且初值均为0; (3)当 i ≤ A.length 且 j ≤ B.length 时,进行A和B的合并。...
  • 【数据结构】顺序表c语言实现

    千次阅读 多人点赞 2019-05-18 15:21:55
    文章目录顺序表c语言实现定义顺序表结构体初始化顺序表操作计算顺序表的长度获取顺序表中元素新元素插入顺序表删除某位置的元素查询某元素的位置打印整个顺序表顺序表的整体源码 线性表的顺序存储是指用一组...
  • 一、线性表线性表(linear list)是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性...2. 动态顺序表:使用动...
  • 顺序表(顺序存储结构)及初始化...顺序表存储数据时,会提前申请一整块足够大小的物理空间,然后将数据依次存储起来,存储时做到数据元素之间不留一丝缝隙。例如,使用顺序表存储集合{1,2,3,4,5}数据最终的存储状态...
  • 本程序实现将两个元素非递减排列的顺序表合并 以下程序用VC++6.0调试,确认正确无误。
  • https://blog.csdn.net/wanzhen4330/article/details/81627034
  • 王道数据结构代码实践----顺序表静态存储C语言版) 前言 日期:2021年8月25日 书籍:王道2021年数据结构考研复习指导 代码内容:实现顺序表的静态存储,包括初始化,插入新元素,删除新元素,输出,查询 代码...
  • 代码对应的博客:https://blog.csdn.net/u011017694/article/details/109196934
  • 顺序表 _c语言练习

    千次阅读 2020-03-09 20:36:55
    线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,采用顺序存储结构的线性表通常称为顺序表顺序表是将表中的结点...
  • /*顺序表只能存储一种数据类型。 为方便以后替换存储类型我们把存储类型命名为Elemtype,当需要存储浮点数类型或字符类型的数据类型时只需要修改int即可*/ typedef struct{ // 定义顺序表 elemtype elem[MAXSIZE];...
  • 顺序表的概念:用一段连续的存储单元存储数据的线性结构,其中连续... 静态的顺序表具有一定局限性,当空间已经满了,仍有数据要插入时,便要扩大空间,于是便有了采用动态数组作为存储结构的动态顺序表。 动态顺...
  • 顺序表顺序储存结构C语言实现版 #include <stdio.h> #define MAXSIZE 100 #define OVERFLOW 0 #define OK 1 #define ERROR 0 int main(){ } //顺序表顺序储存结构 ,这里泛型定义为整形 typedef struct{ ...
  • 目录顺序表的基本操作创建顺序表初始化顺序表销毁顺序表置空顺序表判断顺序表是否为空取顺序表第i个数据元素查找顺序表某数据位置将某数据插入顺序表删除顺序表中某数据遍历顺序表单链表 顺序表的基本操作 创建顺序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,895
精华内容 31,558
关键字:

顺序表动态存储c语言

c语言 订阅