C 顺序表

C 顺序表（Sequence List）

/*
 * sequence_list.c
 * 顺序表
 * sl = sequence list
 * 线性表的顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表中的各数据元素
 * 用这种存储形式的线性表称为顺序表
 * */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAXSIZE 25

/*
 * 顺序表的存储结构
 *     datatype data[MAXSIZE];  // 数组
 *     int last;                   // 最后一个元素在数组中的索引
 *                              // length = last+1
 * */
typedef struct sl {
    int data[MAXSIZE];
    int last;
} sl;

sl *init_sl();
bool insert_sl(sl *list, int index, int value);
bool inserts_sl(sl *list, int values[], int len);
bool delete_sl(sl *list, int index);
int locate_sl(sl *list, int value);
void traverse_sl(sl *list);
sl *merge_sl(sl *la, sl *lb);
void sort_sl(sl *list);

int main(void)
{
    sl *list = init_sl();    

    insert_sl(list, 1, 1);
    insert_sl(list, 2, 2);
    insert_sl(list, 3, 3);
    insert_sl(list, 2, 1);
    traverse_sl(list);
    delete_sl(list, 4);
    traverse_sl(list);

    printf("1 is in [%d]
", locate_sl(list, 1));
    printf("5 is in [%d]
", locate_sl(list, 3));

    sl *adder = init_sl();
    int nums[3] = {7, 8, 9};
    inserts_sl(adder, nums, 3);
    traverse_sl(adder);

    traverse_sl(merge_sl(list, adder));
    sl *sortsl = merge_sl(adder, list);
    traverse_sl(sortsl);
    sort_sl(sortsl);
    traverse_sl(sortsl);


    return 0;
}

/*
 * 初始化顺序表
 * 返回一个顺序表指针
 * last置为-1，表示空
 * */
sl *init_sl() 
{
    sl *list = (sl *)malloc(sizeof(sl));
    list->last = -1;
    return list;
}

/*
 * 在顺序表的index-1位置插入数据value
 * 需要注意，用户输入的index是从1开始数的
 * 而顺序表中索引是从0开始数的
 * 所以需要index-1
 * */
bool insert_sl(sl *list, int index, int value)
{
    /* 确认表是否为空 */
    if (list->last == MAXSIZE - 1) {
        printf("The sequence list is full.
");
        return false;
    }
    /* 插入索引检查，list->data[index]之前必须已经插入数据了 */
    if (index < 1 || index > list->last+2) {
        printf("Wrong index.
");
        return false;
    }
    /*
     * 从last开始，将顺序表中index-1之后的所有数据往后移动一位
     * */
    for (int i = list->last; i >= index-1; i--)
        list->data[i+1] = list->data[i];
    list->data[index-1] = value;
    list->last++;
    return true;
}

/*
 * 将values列表插入到顺序表中去
 * */
bool inserts_sl(sl *list, int values[], int len)
{
    int i, j;

    for (i = 0, j = list->last+2; i < len; i++, j++)
    {
        if(!insert_sl(list, j, values[i]))
            return false;
    }
    
    return true;
}

/*
 * 删除顺序表indexi-1位置上的数据
 * */
bool delete_sl(sl *list, int index)
{
    /* 要删除的索引只能是顺序表中last（包括）之前的索引 
     * 要检查表是否为空，以及索引元素是否存在
     * */
    if (index < 1 || index > list->last+1)
    {
        printf("[%d] doesn't exist.
", index);
        return false;
    }
    /*
     * 从index开始，将顺序表中index-1以后的所有数据都向前移动一位
     * */
    for (int i = index; i <= list->last; i++)
        list->data[i-1] = list->data[i];
    list->last--;
    return true;
}

/*
 * 按照value查找
 * */
int locate_sl(sl *list, int value)
{
    /* 循环查找顺序表中是否有value这个值，判断i是否大于last，如果大于，说明没有value这个值，反之则value存在于i索引上 */
    int i = 0;
    while (i <= list->last && list->data[i] != value)
        i++;    
    if (i > list->last)
        return -1;
    else
        return i+1;
}

/*
 * 遍历顺序表
 * */
void traverse_sl(sl *list)
{
    /* 如果列表为空 */
    if (list->last == -1) {
        printf("[]
");
        return;
    }
    printf("[");
    for (int i = 0; ; i++)
    {
        if (i > list->last)
        {
            printf("]
");
            break;
        }
        printf("%d, ", list->data[i]);
    }
}

/*
 * 整合两个顺序表
 * */
sl *merge_sl(sl *la, sl *lb)
{
    /* 动态分配一个新的顺序表，将la和lb中的数据依次插入其中去 */
    sl *list = (sl *)malloc(sizeof(sl));
    list->last = -1;
    int i, j;

    for (i = 0, j = 1; i <= la->last; i++, j++)
    {
        if (!insert_sl(list, j, la->data[i]))
            break;
    }

    for (i = 0; i <= lb->last; i++, j++)
    {
        if (!insert_sl(list, j, lb->data[i]))
            break;
    }

    return list;
}

/*
 * 顺序表排序
 * 冒泡排序（Bubble Sort）
 * */
void sort_sl(sl *list)
{
    int i, j;

    for (i = list->last; i >= 0; i--) 
    {
        for (j = 0; j < i; j++)
        {
            if (list->data[j] > list->data[j+1])
            {
                int tmp = list->data[j];
                list->data[j] = list->data[j+1];
                list->data[j+1] = tmp;
            }
        }
    }
}