顺序表

于 2017-12-13 15:54:14 发布
阅读量768 收藏 6
点赞数
分类专栏： 数据结构 文章标签： 数据结构 顺序表 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38646470/article/details/78792797
版权

一、顺序表(数组的延伸)

1、静态顺序表（增，删，查，改）

2、动态顺序表 （增，删，查，改）

二、下面来实现顺序表的简单功能（这里只写动态顺序表，静态顺序表是动态的子集）

建立顺序表
typedef int DateType;


typedef struct SeqList
{
    DateType *data;
    size_t size;
    size_t capicity;
}SeqList;

1、顺序表的初始化

void InitList(SeqList* Seq)  //初始化顺序表
{
    Seq->size = 0;
    Seq->capicity=1;
    Seq->data=(DateType*)malloc(Seq->capicity *sizeof(DateType));
    memset(Seq->data,0,Seq->size *sizeof(DateType));
}
2、顺序表的容量判断和扩容 

void ListCheckFull(SeqList *Seq)  //检查容量，并扩容
{
    DateType *tmp;
    assert(Seq);

    if (Seq->size==Seq->capicity)
    {
        tmp= (DateType*)realloc(Seq->data,2*Seq->capicity*sizeof(DateType)+3*sizeof(DateType));
        if (NULL==tmp)
        {
            printf("扩容失败 !\n");
            return;
        }
        else
        {
            Seq->capicity=Seq->capicity*2+3;
            Seq->data=tmp;
        }
    }
}
3、顺序表的插入（包括头插和尾插） 

void ListInsert(SeqList *Seq,size_t pos,DateType x)  //插入(包括头插和尾插)

{
    DateType end=0;
    assert(Seq);
    ListCheckFull(Seq);
    if (pos>Seq->size)
        printf("插入位置无意义\n");
    else
    {
        if (0==Seq->size)  //头插情况
        {
            Seq->data[Seq->size]=x;
            Seq->size++;
        }
        else if(pos==Seq->size)  //尾插情况
        {
            Seq->data[Seq->size]=x;
            Seq->size++;
        }
        else  //随机插入
        {
            end=Seq->size;
            while ((DateType)pos<end)
            {
                Seq->data[end]=Seq->data[end-1];
                end--;
            }
            Seq->data[end]=x;
            Seq->size++;
        }
    }
}
4、顺序表的删除 

void SeqListDelete(SeqList *Seq,size_t pos)  //删除
 {
     size_t tmp=pos-1;;
     assert(Seq);
     
     if (pos>=Seq->size)
     {
         printf("删除数据不存在 ！");
         return ;
     }
     else if (Seq->size==pos)  //尾删
     {
         Seq->size--;
     }
     else
     {
         while (tmp<Seq->size)  //任意位置删除
         {
             Seq->data[tmp]=Seq->data[tmp+1];
             tmp++;
         }
         Seq->size--;
     }
 }
5、顺序表的查找（（1）、遍历查找 （2）、  折半查找）

（1）、遍历查找

DateType SeqListSearch(SeqList *Seq,DateType x)  //遍历查找
{
    DateType i = 0;
    assert(Seq);

    while (i<(int)Seq->size)
    {
        if (Seq->data[i]==x)
            return i;
        i++;
    }
    return -1;
}
（2）、折半查找 

DateType SeqListBinarySearch(SeqList *Seq,DateType x)  //折半查找
{
    DateType start = 0;
    DateType end =Seq->size-1;
    DateType mid = 0;   
    assert(Seq);
    
    while (start<end)
    {
        mid = start+((end-start)>>1);
        if (x<Seq->data[mid])
            end=mid-1;
        else if (x>Seq->data[mid])
            start=mid+1;
        else
           return Seq->data[mid];
    }
    return -1;
}
6、修改顺序表 

void SeqListChange(SeqList *Seq,DateType pos, DateType x)  //修改
{
    size_t tmp;
    assert(Seq);

    tmp = SeqListSearch(Seq,pos);  //找到要修改的位置
    if (tmp != -1)
        Seq->data[tmp]=x;
    else
        printf("修改数不存在！");
}
7、排序顺序表（（1）、冒泡排序  （2）选择排序）

（1）冒泡排序

void SeqListBubbleSort(SeqList *Seq)  //冒泡排序
{
    size_t i = 0;
    size_t j = 0;
    size_t flag =0;

    assert(Seq);

    for (i=0; i<Seq->size-1; i++)
    {
        for (j=0; j<Seq->size-1-i; j++)
        {
            if (Seq->data[j]>Seq->data[j+1])
            {
                flag=1;
                Seq->data[j]^=Seq->data[j+1];
                Seq->data[j+1]^=Seq->data[j];
                Seq->data[j]^=Seq->data[j+1];
            }
        }
        if (flag==0)  //优化冒泡次数
        {
            break;
        }
    }
}
（2）、选择排序 

void SeqListSelectSort(SeqList *Seq)  //选择排序
{
    DateType min;
    DateType max;
    size_t i=0;
    size_t j=0;
    size_t end;
    assert(Seq);

    end=Seq->size-1;
    for (i=0; i<=end; i++)
    {
        min=i;
        max=i;
        for (j=i; j<=end; j++)
        {
            if (Seq->data[j]<Seq->data[min])
                min=j;
            if (Seq->data[max]<Seq->data[j])
                max=j;
        }
        if (min!=i)
        {
            Seq->data[i]^=Seq->data[min];
            Seq->data[min]^=Seq->data[i];
            Seq->data[i]^=Seq->data[min];
        }
         if (max==i)
             max=min;
         if (max!=end)
         {
             Seq->data[end]^=Seq->data[max];
             Seq->data[max]^=Seq->data[end];
             Seq->data[end]^=Seq->data[max];
         }
         end--;
    }

}

三、测试用例

1、插入测试

void test1() //插入测试

{
    InitList(&list);
    PrintList(&list);
    printf("\n");
    ListInsert(&list,0,4);
    ListInsert(&list,1,1);
    ListInsert(&list,2,2);
    ListInsert(&list,2,5);
    ListInsert(&list,2,6);
    ListInsert(&list,3,3);
    ListInsert(&list,5,10);
    ListInsert(&list,2,0);
    PrintList(&list);
    printf("\n");
}

2、删除测试 

void test2()  //删除测试
{
    SeqListDelete(&list,1);
    SeqListDelete(&list,4);
    PrintList(&list);
    printf("\n");
}


3、查找测试 

void test3()  //遍历查找测试
{
    printf("%d ",SeqListSearch(&list,4));
    printf("%d ",SeqListSearch(&list,1));
    printf("%d ",SeqListSearch(&list,6));
    printf("%d ",SeqListSearch(&list,5));
    printf("%d ",SeqListSearch(&list,3));
    printf("%d ",SeqListSearch(&list,2));
    printf("%d ",SeqListSearch(&list,0));
    printf("%d ",SeqListSearch(&list,8));
    printf("\n");
}

4、修改测试 

void test4()  //修改测试
{
    SeqListChange(&list,2,16);
    SeqListChange(&list,3,46);
    SeqListChange(&list,4,16);
    PrintList(&list);
    printf("\n");
}

5、冒泡测试 

void test5()  //冒泡测试
{
    SeqListBubbleSort(&list);
    PrintList(&list);
    printf("\n");
}

6、选择排序测试 

void test6()  //选择排序测试
{
    SeqListSelectSort(&list);
    PrintList(&list);
    printf("\n");

}

四、整体代码

1、SeqList.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

typedef int DateType;

typedef struct SeqList
{
    DateType *data;
    size_t size;
    size_t capicity;
}SeqList;

void InitList(SeqList *Seq);  //初始化顺序表
void PrintList(SeqList *Seq);  //打印顺序表
void ListCheckFull(SeqList *Seq);  //检查是否满了，并扩容
void ListInsert(SeqList *Seq,size_t pos,DateType x);  //随机插入（包括头插和尾插）
void SeqListDelete(SeqList *Seq,size_t pos);  //删除（包括头删和尾删）
DateType SeqListSearch(SeqList *Seq,DateType x);  //顺序查找
DateType SeqListBinarySearch(SeqList *Seq,DateType x);  //二分查找
void SeqListChange(SeqList *Seq,DateType pos,DateType x);  //修改顺序表
void SeqListBubbleSort(SeqList *Seq);  //冒泡排序顺序表
void SeqListSelectSort(SeqList *Seq);  //选择排序顺序表

#endif
2、 SeqList.c 

#include "SeqList.h"

void InitList(SeqList* Seq)  //初始化顺序表
{
    Seq->size = 0;
    Seq->capicity=1;
    Seq->data=(DateType*)malloc(Seq->capicity *sizeof(DateType));
    memset(Seq->data,0,Seq->size *sizeof(DateType));
}

void PrintList(SeqList *Seq)  //打印顺序表
{
    size_t i =0;

    assert(Seq);
    for (i=0; i<Seq->size; i++)
        printf("%d ",Seq->data[i]);
    printf("\n");
}

void ListCheckFull(SeqList *Seq)  //检查容量，并扩容
{
    DateType *tmp;
    assert(Seq);

    if (Seq->size==Seq->capicity)
    {
        tmp= (DateType*)realloc(Seq->data,2*Seq->capicity*sizeof(DateType)+3*sizeof(DateType));
        if (NULL==tmp)
        {
            printf("扩容失败 !\n");
            return;
        }
        else
        {
            Seq->capicity=Seq->capicity*2+3;
            Seq->data=tmp;
        }
    }
}

void ListInsert(SeqList *Seq,size_t pos,DateType x)  //插入(包括头插和尾插)

{
    DateType end=0;
    assert(Seq);
    ListCheckFull(Seq);
    if (pos>Seq->size)
        printf("插入位置无意义\n");
    else
    {
        if (0==Seq->size)  //头插情况
        {
            Seq->data[Seq->size]=x;
            Seq->size++;
        }
        else if(pos==Seq->size)  //尾插情况
        {
            Seq->data[Seq->size]=x;
            Seq->size++;
        }
        else  //随机插入
        {
            end=Seq->size;
            while ((DateType)pos<end)
            {
                Seq->data[end]=Seq->data[end-1];
                end--;
            }
            Seq->data[end]=x;
            Seq->size++;
        }
    }
}


 void SeqListDelete(SeqList *Seq,size_t pos)  //删除
 {
     size_t tmp=pos-1;;
     assert(Seq);
     
     if (pos>=Seq->size)
     {
         printf("删除数据不存在 ！");
         return ;
     }
     else if (Seq->size==pos)  //尾删
     {
         Seq->size--;
     }
     else
     {
         while (tmp<Seq->size)  //任意位置删除
         {
             Seq->data[tmp]=Seq->data[tmp+1];
             tmp++;
         }
         Seq->size--;
     }
 }
 
DateType SeqListSearch(SeqList *Seq,DateType x)  //遍历查找
{
    DateType i = 0;
    assert(Seq);

    while (i<(int)Seq->size)
    {
        if (Seq->data[i]==x)
            return i;
        i++;
    }
    return -1;
} 

DateType SeqListBinarySearch(SeqList *Seq,DateType x)  //折半查找
{
    DateType start = 0;
    DateType end =Seq->size-1;
    DateType mid = 0;   
    assert(Seq);
    
    while (start<end)
    {
        mid = start+((end-start)>>1);
        if (x<Seq->data[mid])
            end=mid-1;
        else if (x>Seq->data[mid])
            start=mid+1;
        else
           return Seq->data[mid];
    }
    return -1;
}

void SeqListChange(SeqList *Seq,DateType pos, DateType x)  //修改
{
    size_t tmp;
    assert(Seq);

    tmp = SeqListSearch(Seq,pos);  //找到要修改的位置
    if (tmp != -1)
        Seq->data[tmp]=x;
    else
        printf("修改数不存在！");
}

void SeqListBubbleSort(SeqList *Seq)  //冒泡排序
{
    size_t i = 0;
    size_t j = 0;
    size_t flag =0;

    assert(Seq);

    for (i=0; i<Seq->size-1; i++)
    {
        for (j=0; j<Seq->size-1-i; j++)
        {
            if (Seq->data[j]>Seq->data[j+1])
            {
                flag=1;
                Seq->data[j]^=Seq->data[j+1];
                Seq->data[j+1]^=Seq->data[j];
                Seq->data[j]^=Seq->data[j+1];
            }
        }
        if (flag==0)  //优化冒泡次数
        {
            break;
        }
    }
}

void SeqListSelectSort(SeqList *Seq)  //选择排序
{
    DateType min;
    DateType max;
    size_t i=0;
    size_t j=0;
    size_t end;
    assert(Seq);

    end=Seq->size-1;
    for (i=0; i<=end; i++)
    {
        min=i;
        max=i;
        for (j=i; j<=end; j++)
        {
            if (Seq->data[j]<Seq->data[min])
                min=j;
            if (Seq->data[max]<Seq->data[j])
                max=j;
        }
        if (min!=i)
        {
            Seq->data[i]^=Seq->data[min];
            Seq->data[min]^=Seq->data[i];
            Seq->data[i]^=Seq->data[min];
        }
         if (max==i)
             max=min;
         if (max!=end)
         {
             Seq->data[end]^=Seq->data[max];
             Seq->data[max]^=Seq->data[end];
             Seq->data[end]^=Seq->data[max];
         }
         end--;
    }

}
3、test.c 

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"

SeqList list;

void test1() //插入测试

{
    InitList(&list);
    PrintList(&list);
    printf("\n");
    ListInsert(&list,0,4);
    ListInsert(&list,1,1);
    ListInsert(&list,2,2);
    ListInsert(&list,2,5);
    ListInsert(&list,2,6);
    ListInsert(&list,3,3);
    ListInsert(&list,5,10);
    ListInsert(&list,2,0);
    PrintList(&list);
    printf("\n");
}

void test2()  //删除测试
{
    SeqListDelete(&list,1);
    SeqListDelete(&list,4);
    PrintList(&list);
    printf("\n");
}
 
void test3()  //遍历查找测试
{
    printf("%d ",SeqListSearch(&list,4));
    printf("%d ",SeqListSearch(&list,1));
    printf("%d ",SeqListSearch(&list,6));
    printf("%d ",SeqListSearch(&list,5));
    printf("%d ",SeqListSearch(&list,3));
    printf("%d ",SeqListSearch(&list,2));
    printf("%d ",SeqListSearch(&list,0));
    printf("%d ",SeqListSearch(&list,8));
    printf("\n");
}

void test4()  //修改测试
{
    SeqListChange(&list,2,16);
    SeqListChange(&list,6,46);
    SeqListChange(&list,5,16);
    PrintList(&list);
    printf("\n");
}

void test5()  //冒泡测试
{
    SeqListBubbleSort(&list);
    PrintList(&list);
    printf("\n");
}

void test6()  //选择排序测试
{
    SeqListSelectSort(&list);
    PrintList(&list);
    printf("\n");

}

void test7()  //折半查找测试
{
    printf("%d ",SeqListBinarySearch(&list,4));
    printf("%d ",SeqListBinarySearch(&list,1));
    printf("%d ",SeqListBinarySearch(&list,6));
    printf("%d ",SeqListBinarySearch(&list,5));
    printf("%d ",SeqListBinarySearch(&list,3));
    printf("%d ",SeqListBinarySearch(&list,2));
    printf("%d ",SeqListBinarySearch(&list,0));
    printf("%d ",SeqListBinarySearch(&list,8));
    printf("\n");
}


int main ()

{
    test1();
    test2();
    test3();
    test4();
    test5();
    test6();
    test7();

  return 0;
}
龙跃十二
关注
专栏目录
C语言实现动态顺序表的实现代码
08-29
C语言实现动态顺序表的实现代码 本文主要介绍了C语言实现动态顺序表的实现代码，动态顺序表是指在内存中开辟一块空间，可以随我们数据数量的增多来扩容的线性表。下面将详细介绍动态顺序表的实现代码。 一、顺序表...
数据结构——顺序表
最新发布
m0_66847953的博客
09-08 835
顺序表是一种基本的数据结构，它通过连续的内存空间来存储数据元素，每个元素占据相同的存储空间，且在逻辑上相邻的元素在物理位置上同样相邻（存储结构）。
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
在本文中，我们将深入探讨如何使用C语言实现一个顺序表来统计单词的出现频率。顺序表是一种基础的数据结构，它将元素存储在一个连续的内存区域中，通过索引来访问元素，具有简单直观的操作方式。 首先，我们需要...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
头歌数据结构顺序表的基本操作1-6关
05-18
【顺序表】是一种基本的数据结构，它在计算机科学中被广泛使用，特别是在处理大量有序或无序数据时。顺序表的实现通常是通过数组来完成的，数组中的元素按顺序存储，便于快速访问和操作。本题涉及顺序表的六种基本...
C++实现顺序表逆置
"这是一个关于顺序表逆置的C++程序实现" 在这个程序中，我们主要讨论了如何在顺序存储结构（顺序表）上进行元素的逆置操作。顺序表是一种简单的数据结构，其中元素按照线性顺序存储在内存中。这个程序涉及到几个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙跃十二

写的不错，给点鼓励

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值