静态顺序表

静态顺序表练习

---

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

////////////////////////////////////////////////////////////////////////////////
typedef int DataType;

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

Seqlist s;

////////////////////////////////////////////////////////////////////////////////////
////seqlist.h
void SeqlistInit(Seqlist *ps);                      //结构体初始化
void SeqlistPush(Seqlist *ps, int data);              //添加数据
void SeqlistPushFront(Seqlist *ps, int data);        //头插
void SeqlistPopFront(Seqlist *ps);                  //头删
void SeqlistPushback(Seqlist *ps, int data);          //尾插
void SeqlistPopback(Seqlist *ps);                    //尾删
void SeqlistInsert(Seqlist *ps, int pos, int data);   //随机插
void SeqlistRemove(Seqlist *ps, int data);          //删除一个data数据
void SeqlistRemoveAll(Seqlist *ps, int data);       //删除所有data数据
void BubbleSort(Seqlist *ps);                       //冒泡排序
void SelectSort(Seqlist *ps);                       //选择排序
int SeqlistFind(Seqlist *ps, int data);             //查找数据
void Swop(int *p, int*q);                           //交换
int BinarySearch(Seqlist *ps, int data);            //二分查找
void SeqlistPrint(Seqlist *ps);                     //打印


/////////////////////////////////////////////////////////////////////////////////
///////seqlist.c


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


//添加数据
void SeqlistPush(Seqlist *ps, int data)
{
    if (NULL == ps)
    {
        assert(0);
        return;
    }
    ps->_array[ps->_size] = data;
    ps->_size++;
}


//头插
void SeqlistPushFront(Seqlist *ps, int data)
{
    int i = 0;
    if (NULL == ps)
    {
        return;
    }
    if (10 == ps->_size)
    {
        printf("无缝可插!!!\n");
        return;
    }
#if 0
    for (i = ps->_size; i >0; i--)
        ps->_array[i] = ps->_array[i-1];

    ps->_array[0] = data;
    ps->_size++;
#endif
    SeqlistInsert(&s, 0, data);
}


//头删
void SeqlistPopFront(Seqlist *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 SeqlistPushback(Seqlist *ps, int data)
{

    if (NULL == ps)
    {
        return;
    }
    if (10 == ps->_size)
    {
        printf("无缝可插!!!\n");
        return;
    }
#if 0
    ps->_array[ps->_size] = data;
    ps->_size++;
#endif

    SeqlistInsert(&s, ps->_size, data);
}


//尾删
void SeqlistPopback(Seqlist *ps)
{
    if (NULL == ps)
    {
        return;
    }
    ps->_size--;
}

//打印
void SeqlistPrint(Seqlist *ps)
{
    int i = 0;
    if (NULL == ps)
    {
        return;
    }
    if (0 == ps->_size)
    {
        printf("顺序表空着呢!!!\n");
    }
    printf("size: %d\n", ps->_size);
    for (i = 0; i < ps->_size; i++)
    {
        printf("%d  ", ps->_array[i]);
    }
    putchar('\n');
}


//随机插
void SeqlistInsert(Seqlist *ps, int pos, int data)
{
    int i = 0;
    if ((NULL == ps)||!(pos>=0 && pos<= ps->_size))
    {
        printf("对不起，数据越界!\n");
        return;
    }
    if (10 == ps->_size)
    {
        printf("表满了啊\n");
        return;
    }
    for (i = ps->_size; i >pos; i--)
    {
        ps->_array[i] = ps->_array[i - 1];
    }
    ps->_array[pos] = data;
    ps->_size++;

}


//查找数据
int SeqlistFind(Seqlist *ps, int data)
{
    int i = 0;
    int j = 0;
    if (NULL == ps)
    {
        return -1;
    }
    for (i = 0; i < ps->_size; i++)
    {
        if (ps->_array[i] == data)
        {
            return i;
        }
    }

}


//二分查找
int BinarySearch(Seqlist *ps, int data)
{
    int left = 0;
    int right = ps->_size;
    int mid = 0;

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

    return -1;
}


//删除一个data的数据
void SeqlistRemove(Seqlist *ps, int data)
{
    int i = 0;
    int j = 0;
    if (NULL == ps)
    {
        return;
    }
    i = SeqlistFind(&s, data);
    for (j = i; j <ps->_size; j++)
    {
        ps->_array[j] = ps->_array[j + 1];
    }
#if 0
    for (i = 0; i < ps->_size; i++)
    {
        if (ps->_array[i] == data);
        {
            for (j = ps->_size; j >i; j--)
            {
                ps->_array[j] = ps->_array[j - 1];
            }
        }
    }
#endif

    ps->_size--;

}


//删除所有data数据
void SeqlistRemoveAll(Seqlist *ps, int 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 -= count;

}

//冒泡排序
void BubbleSort(Seqlist *ps)
{
    int i = 0;
    int j = 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])                        //升序
#if 0
            if (ps->_array[j]<ps->_array[j + 1])                       //降序
#endif
            {
                int tmp = ps->_array[j];
                ps->_array[j] = ps->_array[j + 1];
                ps->_array[j + 1] = tmp;
            }
        }
    }
}



//交换数据
void Swop(int *p, int *q)
{
    int tmp = 0;
    if (NULL == p || NULL == q)
    {
        return;
    }
    tmp = *p;
    *p = *q;
    *q = tmp;
}

//选择排序
void SelectSort(Seqlist *ps)
{
    int max = 0;
    int i = 0;
    int j = 0;
    if (NULL == ps)
    {
        return;
    }
    for (i = 0; i < ps->_size; i++)
    {
        max = 0;
        for (j = 1; j < ps->_size - i; j++)
        {
            if (ps->_array[max]<ps->_array[j])
                max = j;
        }
        Swop(&ps->_array[max], &ps->_array[ps->_size - i - 1]);
    }
}

---

//test.c

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



int main()
{
    SeqlistInit(&s);
    SeqlistPush(&s, 1);
    SeqlistPush(&s, 2);
    SeqlistPush(&s, 3);
    SeqlistPush(&s, 2);
    SeqlistPush(&s, 5);
    SeqlistPush(&s, 8);
    SeqlistPush(&s, 7);
    SeqlistPush(&s, 4);
    SeqlistPush(&s, 3);
    SeqlistPrint(&s);
    //SeqlistPushFront(&s, 6);
    /*SeqlistPopFront(&s);*/
    /*SeqlistPushback(&s, 9);
    SeqlistPrint(&s);
    SeqlistPopback(&s);
    SeqlistPrint(&s);*/
    /*SeqlistInsert(&s, 1, 22);*/
    //SeqlistRemove(&s, 5);
    //SelectSort(&s);
    //SeqlistPrint(&s);
    BubbleSort(&s);
    SeqlistPrint(&s);
    int i = BinarySearch(&s, 7);
    printf("%d\n", i);

    system("pause");
    return 0;
}