静态顺序表的实现

最新推荐文章于 2021-09-01 21:30:20 发布

原创最新推荐文章于 2021-09-01 21:30:20 发布 · 592 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线性表 #顺序表

简单应用同时被 2 个专栏收录

7 篇文章

订阅专栏

简单项目

6 篇文章

订阅专栏

本文介绍了一个简单的静态顺序表实现，包括头插、头删、尾插、尾删等操作，并提供了完整的C语言代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

通过查阅资料的学习，今天我们将实现一个简单的静态顺序表。
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。分为静态顺序表和动态顺序表。
而静态顺序表的实现则依据数据在内存中的连续存储而实现的。例如数组，便是数据在内存中的连续存储。
接下来介绍的这个静态顺序表便能实现数据的头插、头删，尾插、尾删，显示，指定位的插入，指定位的删除，指定元素的删除，指定元素的查找，逆序写入的元素，排序以及二分查找等功能。代码实现如下：

**sequence.h**

#ifndef __SEQU_H__
#define __SEQU_H__
#include<stdio.h>
#include<assert.h>
#include<string.h>

typedef int TypeData;
#define MAX 10
typedef struct Seqlist
{
    TypeData data[MAX];
    int sz;
}Seqlist, *pSeqlist;

void Initseqlist(pSeqlist ps);//初始化  
void PushBack(pSeqlist ps, TypeData d);//尾插
void Display(pSeqlist ps);//显示
void PopBack(pSeqlist ps);//尾删
void PushFront(pSeqlist ps, TypeData d);//头插
void PopFront(pSeqlist ps);//头删
int Find(pSeqlist ps, TypeData d);//查找
void Remove(pSeqlist ps, TypeData d);//指定位的删除
void RemoveAll(pSeqlist ps, TypeData d);//指定元素的全部删除
void Insert(pSeqlist ps, TypeData d, int pos);//指定位插入某个数
void Reverse(pSeqlist ps);//逆序
void Sort(pSeqlist ps);//排序
int BinarySearch(pSeqlist ps, TypeData d);//二分查找

#endif//__SEQU_H__

**sequence.c**

#define _CRT_SECURE_NO_WARNINGS 1
#include "sequence.h"

void Initseqlist(pSeqlist ps)//初始化
{
    assert(ps != NULL);
    ps->sz = 0;
    memset(ps->data, 0, sizeof(TypeData)*(ps->sz));
}

void PushBack(pSeqlist ps, TypeData d)//尾插
{
    assert(ps != NULL);
    if (ps->sz < MAX)
    {
        ps->data[ps->sz] = d;
        ps->sz++;
    }
}

void Display(pSeqlist ps)//显示
{
    assert(ps != NULL);
    int i = 0;
    for (i = 0; i < ps->sz; i++)
    {
        printf("%d ", ps->data[i]);
    }
    printf("\n");
}

void PopBack(pSeqlist ps)//尾删
{
    assert(ps != NULL);
    if (ps->sz == 0)
    {
        return;
    }
    ps->sz--;
}

/*void *memmove( void *dest, const void *src, size_t count );*/  //memmove的原型
void PushFront(pSeqlist ps, TypeData d)//头插
{
    assert(ps != NULL);
    int i = 0;
    if (ps->sz < MAX)//两种实现方式
    {
        //mommove的效率更高，可以实现内存重叠部分的拷贝
        memmove(ps->data + 1, ps->data, sizeof(TypeData)*(ps->sz));

        //利用for循环
        /*for (i = ps->sz; i > 0; i--)
        {
            ps->data[i] = ps->data[i-1];
        }*/
    }
    ps->data[0] = d;
    ps->sz++;
}

void PopFront(pSeqlist ps)//头删
{
    int i = 0;
    assert(ps != NULL);
    if (ps->sz == 0)
    {
        return;
    }
    for (i = 0; i < ps->sz; i++)
    {
        ps->data[i] = ps->data[i + 1];
    }
    ps->sz--;
}

int Find(pSeqlist ps, TypeData d)//查找
{
    int i = 0;
    for (i = 0; i < ps->sz-1; i++)
    {
        if (d == ps->data[i])
        {
            return i;
        }
    }
        return -1;
}


void Remove(pSeqlist ps, TypeData d)//指定位置的删除
{
    assert(ps != NULL);
    int pos = 0;
    int i = 0;
    pos = Find(ps, 1);
    if (pos != -1)
    {
        for (i = 0; i < ps->sz; i++)
        {
            ps->data[i] = ps->data[i+1];
        }
    }
    ps->sz--;
}

void RemoveAll(pSeqlist ps, TypeData d)//指定元素的删除
{
    assert(ps != NULL);
    int i = 0;
    for (i = 0; i < ps->sz; i++)
    {
        if (d == ps->data[i])
        {
            ps->data[i] = ps->data[i + 1];
            ps->sz--;
        }
    }

}

void Insert(pSeqlist ps, TypeData d, int pos)//指定位置插入
{
    assert(ps != NULL);
    int i = 0;
    if (ps->sz  == MAX)
    {
        return;
    }

    /*for (i = ps->sz; i > pos; i--)
    {
        ps->data[i] = ps->data[i - 1];
    }*/

    memmove(ps->data + pos + 1, ps->data + pos, sizeof(TypeData)*(ps->sz - pos));
    ps->data[pos] = d;

    ps->sz++;
}

void Reverse(pSeqlist ps)//逆序
{
    TypeData tmp = 0;
    TypeData *left = ps->data;
    TypeData *right = ps->data + (ps->sz) - 1;
    while (left < right)
    {
        tmp = *left;
        *left=*right;
        *right = tmp;
        left++;
        right--;
    }
}

void Sort(pSeqlist ps)//冒泡排序
{
    int i = 0;
    int j = 0;
    for (i = 0; i < ps->sz-1; i++)
    {
        for (j = 0; j < ps->sz - i - 1; j++)
        {
            if (ps->data[j]>ps->data[j + 1])//升序
            {
                TypeData tmp = ps->data[j];
                ps->data[j] = ps->data[j + 1];
                ps->data[j + 1] = tmp;
            }
        }
    }
}

int BinarySearch(pSeqlist ps, TypeData d)//二分查找
{
    int left = 0;
    int right =ps->sz - 1;
    while (left <= right)  //在等于之时，未使其进来，所以没有进来判断
    {
        int mid = left + (right - left) / 2;
        if (ps->data[mid]>d)
        {
            right = mid - 1;
        }
        else if (ps->data[mid] < d)
        {
            left = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;//没找到
    //表示循环结束，，return的含义便是，只要找到，则直接结束程序
}

下面部分为测试部分

**test.c**

为了实现以上功能，将测试部分分为五部分，从而有利于大家的查看。

#define _CRT_SECURE_NO_WARNINGS 1
#include "sequence.h"
void menu()
{
    printf("***********************\n");
    printf("****    1 Test1   ****\n");
    printf("****    2 Test2   ****\n");
    printf("****    3 Test3   ****\n");
    printf("****    4 Test4   ****\n");
    printf("****    5 Test5   ****\n");
    printf("****    0 Exit    *****\n");
}

void Test1()
{
    Seqlist my_list;
    Initseqlist(&my_list);
    PushBack(&my_list,1);//从尾部插入
    PushBack(&my_list,2);
    PushBack(&my_list,3);
    PushBack(&my_list, 5);
    PushBack(&my_list,4);
    Display(&my_list);//显示

    PopBack(&my_list);//从尾部删除
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
    PopBack(&my_list);
    Display(&my_list);
}
void Test2()
{
    Seqlist my_list;
    Initseqlist(&my_list);
    PushFront(&my_list, 1);//从头部插入
    PushFront(&my_list, 2);
    PushFront(&my_list, 3);
    PushFront(&my_list, 4);
    Display(&my_list);

    PopFront(&my_list);//从头部删除
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
    PopFront(&my_list);
    Display(&my_list);
}

void Test3()
{
    Seqlist my_list;
    Initseqlist(&my_list);
    PushFront(&my_list, 1);//从头部插入
    PushFront(&my_list, 2);
    PushFront(&my_list, 3);
    PushFront(&my_list, 4);
    Display(&my_list);

    int ret = Find(&my_list, 1);//查找某个函数
    printf("%d\n", ret);

    Remove(&my_list, 1);//删除指定位置的元素
    RemoveAll(&my_list, 1);//删除指定元素
    Display(&my_list); 
}   
void Test4()
{
    Seqlist my_list;
    Initseqlist(&my_list);
    PushBack(&my_list,1);//从尾部插入
    PushBack(&my_list,2);
    PushBack(&my_list,3);
    PushBack(&my_list, 5);
    PushBack(&my_list,4);
    Display(&my_list);//显示
    Insert(&my_list, 6, 2);//插入
    Display(&my_list);
    Reverse(&my_list);//逆序
    Display(&my_list);
}
void Test5()
{
    Seqlist my_list;
    Initseqlist(&my_list);
    PushBack(&my_list,1);//从尾部插入
    PushBack(&my_list,2);
    PushBack(&my_list,3);
    PushBack(&my_list, 5);
    PushBack(&my_list,4);
    Display(&my_list);//显示
    Sort(&my_list);//排序
    Display(&my_list);
    int tmp = BinarySearch(&my_list,2);//二分查找
}

int main()
{
    int input = 0;
    do{
        menu();
        printf("请选择： ");
        scanf("%d", &input);
        switch (input)
        {
        case 0:
            break;
        case 1:
            Test1();
            break;
        case 2:
            Test2();
            break;
        case 3:
            Test3();
            break;
        case 4:
            Test4();
            break;
        case 5:
            Test5();
            break;
        default:
            break;
        }
    } while (input);
    system("pause");
    return 0;
}