静态顺序表

静态顺序表

//Sequlist.h
#pragma once
#include<stdio.h>
#define MAX_SIZE 10

typedef int  Datatype;
typedef struct SequList
{
    Datatype _array[MAX_SIZE];
    int _size;           //顺序表中有效元素的个数
}Sequlist;

Sequlist s;


void Sequlistinit(Sequlist *ps);//顺序表的初始化
void Sequlistpush(Sequlist *ps, Datatype data);//向顺序表中添加数据
void SequlistPushBack(Sequlist *ps, Datatype data);//顺序表的尾插
void SequlistPopBack(Sequlist *ps);    //顺序表的尾删
void SequlistPushFront(Sequlist *ps, Datatype data);//顺序表的头插
void SequlistPopFront(Sequlist *ps); //顺序表的头删
void Sequlistinsert(Sequlist *ps, int pop, Datatype data);//顺序表pop的位置插入元素data
void Sequlisterase(Sequlist *ps, int pop);//删除顺序表pop位置的元素
void Remove(Sequlist *ps, Datatype data);//移除顺序表中第一个为data的元素
void Removeall(Sequlist *ps, Datatype data);//移除顺序表中所有值为data的元素
int Sequlistfind(Sequlist *ps, Datatype data);//在顺序表中查找值为data的元素，找到则返回该元素在顺序表中的位置，否则返回-1；
int Sequlistsize(Sequlist *ps); //获取顺序表中元素的个数
void PrintSequlist(Sequlist *ps); //打印顺序表
void Bubble_Sort(Sequlist *ps);//使用冒泡排序对顺序表中的元素进行排序



void Sequlistinit(Sequlist *ps)//结构体的初始化
{
    if (NULL == ps)
    {
        return;
    }
    ps->_size = 0;


}
void Sequlistpush(Sequlist *ps, Datatype data)//向顺序表中添加数据
{
    if (NULL == ps)
    {
        return;
    }
    ps->_array[ps->_size] = data;
    ps->_size++;

}
void SequlistPushBack(Sequlist *ps, Datatype data)//顺序表的尾插
{
    if (NULL == ps)
    {
        return;
    }
    if (10 == ps->_size)
    {
        printf("顺序表满了，在尾部插不了了！\n");
        return;

    }
    ps->_array[ps->_size] = data;
    ps->_size++;

}
void SequlistPopBack(Sequlist *ps)   //顺序表的尾删
{
    if (NULL == ps)
    {
        return;
    }
    ps->_size--;


}
void SequlistPushFront(Sequlist *ps, Datatype data)//顺序表的头插
{
    int i = 0;
    if (NULL == ps)
    {
        return;
    }
    if (10 == ps->_size)
    {
        printf("顺序表满了，在头部插不了了！");
        return;
    }
    for (i = ps->_size; i>0; i--)
    {
        ps->_array[i] = ps->_array[i - 1];
        ps->_array[0] = data;
        ps->_size++;

    }
}
void SequlistPopFront(Sequlist *ps) //顺序表的头删
{
    int i = 0;
    if (NULL == ps)
    {
        return;
    }
    for (i = 0; i<ps->_size - 1; i++)
    {
        ps->_array[i] = ps->_array[i + 1];
        ps->_size--;

    }
}

void Sequlistinsert(Sequlist *ps, int pop, Datatype data)//顺序表pop的位置插入元素data
{
    int i = 0;
    if (NULL == ps)
    {
        return;
    }
    if (10 == ps->_size)
    {
        printf("顺序表满了，不能插入元素!\n");
    }
    if (pop<0 || pop>10)
    {
        printf("该位置不正确，不能插入元素!\n");
        return;
    }
    for (i = ps->_size; i>pop; i--)
    {
        ps->_array[i] = ps->_array[i - 1];
        ps->_array[pop] = data;
        ps->_size++;

    }
}
void Sequlisterase(Sequlist *ps, int pop)//删除顺序表pop位置的元素
{
    int i = 0;
    if (NULL == ps)
    {
        return;
    }
    if (pop<0 || pop>10)
    {
        printf("该位置不正确，不能删元素!\n");
        return;
    }
    for (i = pop; i < ps->_size; i++)
    {
        ps->_array[i] = ps->_array[i + 1];
    }
    ps->_size--;
}


void Remove(Sequlist *ps, Datatype data)//移除顺序表中第一个为data的元素
{
    int i = 0;
    int j = 0;
    if (NULL == ps)
    {
        return;
    }

    for (i = 0; i<ps->_size; i++)
    {
        if (ps->_array[i] == data)
        {
            for (j = 0; j<ps->_size - 1; j++)
            {
                ps->_array[j] = ps->_array[j + 1];
                ps->_size--;

            }

        }
    }
}

void Removeall(Sequlist *ps, Datatype data) //移除顺序表中所有值为data的元素
{
    int i = 0;
    int count = 0;
    if (NULL == ps)
    {
        return;
    }
    for (i = 0; i<ps->_size; i++)
    {
        if (ps->_array[i] == data)
        {
            count++;
        }
        else
        {
            ps->_array[i - count] = ps->_array[i];

        }

    }
    ps->_size = ps->_size - count;
}


int Sequlistfind(Sequlist *ps, Datatype data)//在顺序表中查找值为data的元素，找到则返回该元素在顺序表中的位置，否则返回-1；二分查找
{
    int left = 0;
    int right= ps->_size;
    int mid = 0;
    if (NULL == ps)
    {
        return -1;
    }

    while (left <= mid)
    {
        mid = left + (right - left) / 2;
        if (data == ps->_array[mid])
        {
            return mid;
        }
        else if (data>ps->_array[mid])
        {
            left = mid + 1;
        }
        else if(data<ps->_array[mid])
        {
            right = mid - 1;
        }
    }

    return -1;

}
int Sequlistsize(Sequlist *ps) //获取顺序表中元素的个数
{
    int i = 0;
    if (NULL == 0)
    {
        return 0;
    }
    if (0 == ps->_size)
    {
        printf("顺序表为空!\n");
    }
    printf("顺序表元素个数为：%d\n", ps->_size);


}
void PrintSequlist(Sequlist *ps)  //打印顺序表
{
    int i = 0;

    if (NULL == ps)
    {
        return;
    }
    if (10 == ps->_size)
    {
        printf("顺序表为满!\n");
    }
    if (0 == ps->_size)
    {
        printf("顺序表为空!\n");
    }
    for (i = 0; i<ps->_size; i++)
    {
        printf("%d\n", ps->_array[i]);

    }
}


void Bubble_Sort(Sequlist *ps)//使用冒泡排序对顺序表中的元素进行排序
{
    int i = 0;
    int j = 0;
    int tmp = 0;
    if (NULL == ps)
    {
        return;
    }
    for (i = 0; i<ps->_size - 1; i++)
    {
        for (j = 0; j<ps->_size - 1 - i; j++)
        {
            if (ps->_array[j]>ps->_array[j + 1])
            {
                tmp = ps->_array[j];
                ps->_array[j] = ps->_array[j + 1];
                ps->_array[j + 1] = tmp;

            }
        }
    }
}

测试代码：

//test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"Sequlist.h"
#include<Windows.h>
int main()
{
    Sequlistinit(&s);
    Sequlistpush(&s, 1);
    Sequlistpush(&s, 2);
    Sequlistpush(&s, 4);
    Sequlistpush(&s, 3);
    Sequlistpush(&s, 6);
    Sequlistpush(&s, 5);
    SequlistPushBack(&s, 7);//顺序表的尾插
    SequlistPopBack(&s);    //顺序表的尾删
    SequlistPushFront(&s, 0);//顺序表的头插
    SequlistPopFront(&s); //顺序表的头删
    Sequlistinsert(&s, 4, 8);//顺序表pop的位置插入元素data
    Sequlisterase(&s, 4);//删除顺序表pop位置的元素
    Remove(&s, 2);//移除顺序表中第一个为data的元素
    Removeall(&s, 3);//移除顺序表中所有值为data的元素
    Sequlistfind(&s, 6);//在顺序表中查找值为data的元素，找到则返回该元素在顺序表中的位置，否则返回-1；
    Sequlistsize(&s); //获取顺序表中元素的个数
    PrintSequlist(&s); //打印顺序表
    Bubble_Sort(&s);//使用冒泡排序对顺序表中的元素进行排序
    system("pause");
    return 0;
}