C语言实现静态顺序表

C语言动态顺序表实现：http://blog.csdn.net/qq_34021920/article/details/65450516

接下来看看静态的顺序表，直接上代码：

SeqList.h

#define _CRT_SECURE_NO_WARNINGS 1

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include 
#include 
#include 
#include 

#define MAX 10

typedef int DataType;

typedef struct SeqList
{
    DataType data[MAX];
    int sz;
}SeqList,*pSeqList;

void InitSeqList(pSeqList ps);
void PushBack(pSeqList ps, DataType d);
void PopBack(pSeqList ps);
void PushFront(pSeqList ps, DataType d);
void PopFront(pSeqList ps);
void Display(const pSeqList ps);
int Find(pSeqList ps, DataType d);
void Insert(pSeqList ps, DataType d, int pos);
void Remove(pSeqList ps, DataType d);
void RemoveAll(pSeqList ps, DataType d);
void Reverse(pSeqList ps);
void Sort(pSeqList ps);
int BinarySearch(pSeqList ps, DataType d);

#endif//__SEQLIST_H__

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"

void InitSeqList(pSeqList ps)
{
    assert(ps);
    ps->sz = 0;
    memset(ps->data, 0, sizeof(DataType)*MAX);
}
void PushBack(pSeqList ps, DataType d)
{
    assert(ps);
    if (ps->sz == MAX)
    {
        return;
    }
    ps->data[ps->sz] = d;
    ps->sz++;
}
void PopBack(pSeqList ps)
{
    assert(ps);
    if (ps->sz == 0)
    {
        return;
    }
    ps->sz--;
}
void PushFront(pSeqList ps, DataType d)
{
    int i = 0;
    assert(ps);
    for (i = ps->sz; i >= 1; i--)
    {
        ps->data[i] = ps->data[i - 1];
    }
    ps->data[0] = d;
    ps->sz++;
}
void PopFront(pSeqList ps)
{
    int i = 0;
    assert(ps);
    for (i = 0; i < ps->sz; i++)
    {
        ps->data[i] = ps->data[i + 1];
    }
    ps->sz--;
}
void Display(const pSeqList ps)
{
    int i = 0;
    assert(ps);
    for (i = 0; i < ps->sz; i++)
    {
        printf("%d ", ps->data[i]);
    }
    printf("\n");
}
int Find(pSeqList ps, DataType d)
{
    int i = 0;
    assert(ps);
    for (i = 0; i < ps->sz; i++)
    {
        if (ps->data[i] == d)
        {
            return i;
        }
    }
    return -1;
}
void Insert(pSeqList ps, DataType d, int pos)
{
    int i = 0;
    assert(ps);
    if (ps->sz == MAX)
    {
        return;
    }
    //方式一
    //for (i = ps->sz - 1; i >= pos; i--)
    //{
    //  ps->data[i + 1] = ps->data[i];
    //}
    //方式二
    memmove(ps->data + pos + 1, ps->data + pos, sizeof(DataType)*(ps->sz - pos));
    ps->data[pos] = d;
    ps->sz++;
}
void Remove(pSeqList ps, DataType d)
{
    int i = 0;
    int pos = 0;
    assert(ps);
    pos = Find(ps, d);
    if (pos != -1)
    {
        for (i = pos; i < ps->sz; i++)
        {
            ps->data[i] = ps->data[i + 1];
        }
        ps->sz--;
    }
}
void RemoveAll(pSeqList ps, DataType d)
{
    int i = 0;
    int pos = 0;
    assert(ps);
    pos = Find(ps, d);
    while ((pos = Find(ps, d)) != -1)
    {
        for (i = pos; i < ps->sz; i++)
        {
            ps->data[i] = ps->data[i + 1];
        }
        ps->sz--;
    }
}
void Reverse(pSeqList ps)
{
    int left = 0;
    int right = ps->sz - 1;
    assert(ps);
    while (left < right)
    {
        DataType tmp = ps->data[right];
        ps->data[right] = ps->data[left];
        ps->data[left] = tmp;
        left++;
        right--;
    }
}
void Sort(pSeqList ps)
{
    int i = 0;
    int j = 0;
    assert(ps);
    for (i = 0; i < ps->sz; i++)
    {
        for (j = 0; j < ps->sz - i - 1; j++)
        {
            if (ps->data[j]>ps->data[j + 1])
            {
                DataType tmp = ps->data[j];
                ps->data[j] = ps->data[j + 1];
                ps->data[j + 1] = tmp;
            }
        }
    }
}
int BinarySearch(pSeqList ps, DataType d)
{
    int left = 0;
    int right = ps->sz - 1;
    while (left <= right)
    {
        int mid = left - ((left - right) >> 1);
        if (d > ps->data[mid])
        {
            left = mid + 1;
        }
        else if (d < ps->data[mid])
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"

void test1()
{
    SeqList list;
    InitSeqList(&list);
    PushBack(&list, 1);
    PushBack(&list, 2);
    PushBack(&list, 3);
    PushBack(&list, 4);
    Display(&list);
    PopBack(&list);
    Display(&list);
    PopBack(&list);
    Display(&list);
    PopBack(&list);
    Display(&list);
    PopBack(&list);
    Display(&list);
}

void test2()
{
    int pos = 0;
    SeqList list;
    InitSeqList(&list);
    PushFront(&list, 1);
    PushFront(&list, 2);
    PushFront(&list, 3);
    PushFront(&list, 2);
    PushFront(&list, 4);
    PushFront(&list, 2);
    Display(&list);
    pos = Find(&list, 3);
    printf("%d\n", list.data[pos]);
    PopFront(&list);
    Display(&list);
    PopFront(&list);
    Display(&list);
    PopFront(&list);
    Display(&list);
    PopFront(&list);
    Display(&list);
}
void test3()
{
    int pos = 0;
    SeqList list;
    InitSeqList(&list);
    PushFront(&list, 1);
    PushFront(&list, 2);
    PushFront(&list, 3);
    PushFront(&list, 2);
    PushFront(&list, 4);
    PushFront(&list, 2);
    Display(&list);
    Insert(&list, 6, 2);
    Display(&list);
    Remove(&list, 1);
    Display(&list);
    RemoveAll(&list, 2);
    Display(&list);
}
void test4()
{
    int pos = 0;
    SeqList list;
    InitSeqList(&list);
    PushFront(&list, 1);
    PushFront(&list, 2);
    PushFront(&list, 3);
    PushFront(&list, 2);
    PushFront(&list, 4);
    Display(&list);
    Reverse(&list);
    Display(&list);
    Sort(&list);
    Display(&list);
    pos = BinarySearch(&list, 3);
    printf("%d\n", list.data[pos]);
}
int main()
{
    test4();
    system("pause");
    return 0;
}