static sequence table

Test environment: vs2013

SeqList.h file

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

typedef struct SeqList
{
    int arr[MAX_SIZE];
    int size; // 表示顺序表中有效元素的个数 
}SeqList, *PSeqList;




// 顺序表的初始化 
void SeqListInit(PSeqList ps);

// 顺序表的尾插 
void SeqListPushBack(PSeqList ps, int data);

// 顺序表的尾删 
void SeqListPopBack(PSeqList ps);

// 顺序表的头插 
void SeqListPushFront(PSeqList ps, int data);

// 顺序表的头删 
void SeqListPopFront(PSeqList ps);

// 顺序表pos位置插入元素data 
void SeqListInsert(PSeqList ps, int pos, int data);

// 删除顺序表pos位置元素 
void SeqListErase(PSeqList ps, int pos);

// 移除顺序表中第一个值为data的元素 
void Remove(PSeqList ps, int data);

// 移除顺序表中所有值为data的元素 
void RemoveAll(PSeqList ps, int data);

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1 
int SeqListFind(PSeqList ps, int data);

// 获取顺序表中元素的个数 
int SeqListSize(PSeqList ps);
//辅助操作 
// 打印顺序表 
void PrintSeqList(PSeqList ps);

// 使用冒泡排序对顺序表中的元素进行排序 
void BubbleSort(PSeqList ps);

//使用选择排序对顺序表中的元素进行排序 
void SelectSort(PSeqList ps);

SeqList.c file

#include "SeqList.h"

void SeqListInit(PSeqList ps)
{
    if (NULL == ps)
        return;
    ps->size = 0;
}

void SeqListPushBack(PSeqList ps, int data)
{
    if (NULL == ps)
        return;

    if (ps->size == MAX_SIZE)
        printf("表已满，操作失败!!!\n");

    ps->arr[ps->size] = data;//插入成功
    ps->size++;
}

void SeqListPopBack(PSeqList ps)
{
    if (NULL == ps)
        return;

    if (ps->size == 0)
        printf("表已空，操作失败!!!\n");

    ps->size--;
}

void SeqListPushFront(PSeqList ps, int data)
{
    int i = 0;
    if (NULL == ps)
        return;

    if (ps->size == MAX_SIZE)
        printf("表已满，操作失败!!!\n");

    for (i = ps->size; i > 0; i--)
    {
        ps->arr[i] = ps->arr[i -1];//元素移位
    }
    ps->arr[0] = data;//插入成功
    ps->size++;
}

void SeqListPopFront(PSeqList ps)
{
    int i = 0;
    if (NULL == ps)
        return;

    if (ps->size == 0)
        printf("表已空，操作失败!!!\n");

    for (; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;//删除成功
}

void SeqListInsert(PSeqList ps, int pos, int data)
{
    int i = 0;
    if (NULL == ps || !((pos >= 0) && (pos <= ps->size)))
        return;

    if (ps->size == MAX_SIZE)
        printf("表已满，操作失败!!!\n");

    for (i = ps->size; i > pos; i--)
    {
        ps->arr[i] = ps->arr[i - 1];
    }
    ps->size++;
}

void SeqListErase(PSeqList ps, int pos)
{
    int i = pos;
    if (NULL == ps || !((pos >= 0) && (pos < ps->size)))
        return;

    if (ps->size == 0)
        printf("表已空，操作失败!!!\n");

    for (; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }

    ps->size--;
}

int SeqListFind(PSeqList ps, int data)
{
    int i = 0;
    for (; i < ps->size; i++)
    {
        if (ps->arr[i] == data)
            return i;
    }
    return -1;
}

void Remove(PSeqList ps, int data)
{
    if (NULL == ps)
        return;

    int pos = SeqListFind(ps, data);
    SeqListErase(ps, pos);

}

void RemoveAll(PSeqList ps, int data)
{
    //1.创建临时数组，将不是该数据的所有数据移到创建的临时数组中，然后再覆盖  时间O(n)  空间O(n)
    //2.找n-1躺， 每趟删除一个 空间复杂度O（1） 时间O（n^2）
    //3.
    int count = 0;
    int i = 0;

    for (; i < ps->size; i++)
    {
        if (ps->arr[i] == data)
            count++;
        else
            ps->arr[i - count] = ps->arr[i];//朝前搬移count位

    }
    ps->size -= count;

}

int SeqListSize(PSeqList ps)
{
    return ps->size;
}

void PrintSeqList(PSeqList ps)
{
    int i = 0;
    printf("size = %d\n", ps->size);

    for (; i < ps->size; i++)
    {
        printf("%d ", ps->arr[i]);
    }
}

static void Swap(int *dest, int *src)
{
    *dest ^= *src;
    *src ^= *dest;
    *dest ^= *src;
}

void BubbleSort(PSeqList ps)
{
    int i = 0;
    for (; i < ps->size - 1; i++)
    {
        int j = 0;
        int flag = 0;
        for (; j < ps->size - 1 - i; j++)
        {
            if (ps->arr[j] > ps->arr[j + 1])//从小到大
            {
                Swap(&(ps->arr[j]), &(ps->arr[j+1]));
                flag = 1;
            }
            if (flag == 0)
            return;
        }
    }
}
//缺陷：1.已经有序不能退出
//      2.重复性操作太多
void SelectSort(PSeqList ps)
{
    int i = 0;
    for (; ps->size - 1; i++)
    {
        int maxPos = 0;
        int j = 0;
        for (j = 1; j < ps->size - i; j++)
        {
            if (ps->arr[j] > ps->arr[maxPos])
            {
                maxPos = j;
            }       
        }

        if (maxPos != p->size - i - j);
        Swap(&(ps->arr[maxPos]), &(ps->arr[j-1]));
    }
}

test.c file

#include "SeqList.h"
#include <windows.h>

int main()
{
    SeqList A;
    PSeqList ps = &A;

    // 顺序表的初始化 
    SeqListInit(ps);
    // 顺序表的尾插 
    SeqListPushBack(ps, 0);
    SeqListPushBack(ps, 5);
    SeqListPushBack(ps, 3);
    SeqListPushBack(ps, 2);
    SeqListPushBack(ps, 7);
    SeqListPushBack(ps, 5);
    SeqListPushBack(ps, 5);
    SeqListPushBack(ps, 3);
    SeqListPushBack(ps, 1);
    //顺序表任意位置插入
    SeqListInsert(ps, 3, 2);

    // 删除顺序表pos位置元素 
    SeqListErase(ps, 2);

    // 移除顺序表中第一个值为data的元素 
    Remove(ps,5);

    // 移除顺序表中所有值为data的元素 
    RemoveAll(ps, 2);

    // 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1 
    SeqListFind(ps, 5);
    // 获取顺序表中元素的个数 
    SeqListSize(ps);

    // 使用冒泡排序对顺序表中的元素进行排序 
    BubbleSort(ps);

    //使用选择排序对顺序表中的元素进行排序 
    SelectSort(ps);

    PrintSeqList(ps);

    system("pause");
    return 0;
}