Linux学习之路（9）

单链表

main.c

#include <stdio.h>
#include "Seq.h"

int main()
{
    Seq *s = Create();
    if (NULL == s)
    {
        printf ("创建顺序表失败\n");
    }
    
    printf ("创建顺序表成功\n");
    
    
    int i;
    for (i = 0; i < 18; i++)
    {
        // Insert_Last(s, i);
        Insert_Head(s, i);
    }
    
    Display(s);
    Insert_Pos(s, 0, 100);
    Display(s);
    
    Insert_Pos(s, s->size, 200);
    Display(s);
    
    Insert_Pos(s, 5, 123);
    Display(s);
    
    printf ("------------------------\n");
    Delete_Pos(s, 5);
    Display(s);
    
    Delete_Pos(s, s->size-1);
    Display(s);
    
    Delete_Pos(s, 0);
    Display(s);
    
    Destroy(s);
    
    return 0;
}

 

 

 

Seq.c

#include "Seq.h"
#include <stdlib.h>
#include <stdio.h>

Seq* Create()
{
    Seq *s = (Seq*)malloc(sizeof(Seq)/sizeof(char));
    if (NULL == s)
        return NULL;
    
    // 给顺序表分配空间
    s->pData = (Data*)malloc(sizeof(Data)/sizeof(char) * INIT_SIZE);
    if(NULL == s->pData)
    {
        free(s);
        return NULL;
    }
    
    s->maxSize = INIT_SIZE;
    s->size    = 0;
    
    return s;
}

BOOL AgainMalloc(Seq* s)
{
    if(NULL == s)
        return ERROR;
    
    int newSize = sizeof(Data)/sizeof(char)*(s->maxSize+ADD_SIZE);
    
    Data* p = (Data*)realloc(s->pData, newSize);
    if (NULL == p)
        return FALSE;
    
    s->pData    = p;
    s->maxSize += ADD_SIZE;
    
    return TRUE;
}

BOOL Insert_Last(Seq* s, Data data)
{
    if (NULL == s)
        return ERROR;
    
    if (s->size == s->maxSize)
    {
        if (AgainMalloc(s) != TRUE)
            return FALSE;
    }
    
    s->pData[s->size++] = data;
    
    
    return TRUE;
}

BOOL Insert_Head(Seq* s, Data data)
{
    if (NULL == s)
        return ERROR;
    
    if (s->size == s->maxSize)
    {
        if (AgainMalloc(s) != TRUE)
            return FALSE;
    }
    
    int i = 0;
    for (i = s->size-1; i>=0; i--)
    {
        s->pData[i+1] = s->pData[i];        
    }
    s->pData[0] = data;
    s->size++;
    
    return TRUE;
}

BOOL Insert_Pos(Seq* s, int index, Data data)
{
    if (NULL == s || index < 0 || index > s->size)
        return ERROR;
    
    if (s->size == s->maxSize)
    {
        if (AgainMalloc(s) != TRUE)
            return FALSE;
    }
    
    int i = 0;
    for (i = s->size-1; i>=index; i--)
    {
        s->pData[i+1] = s->pData[i];        
    }
    s->pData[index] = data;
    s->size++;
    
    return TRUE;
}

BOOL Delete_Pos(Seq* s, int index)
{
    if (NULL == s || index < 0 || index >= s->size)
        return ERROR;
    

    int i;
    for (i = index; i <s->size-1; i++)
    {
        s->pData[i] = s->pData[i+1];
    }
    s->size--;
    
    return TRUE;
}

void Display(Seq* s)
{
    if (NULL == s)
        return;
    
    int i;
    for (i = 0; i < s->size; i++)
    {
        printf ("%-4d", s->pData[i]);
    }
    printf ("\n");
}

 

 

 

 

 

 

 

 

void Destroy(Seq* s)
{
    if (NULL == s)
        return;
    
    free(s->pData);
    free(s);
}

 

Seq.h

#ifndef _SEQ_H_
#define _SEQ_H_

#define INIT_SIZE  10
#define ADD_SIZE   5

typedef enum {TRUE, FALSE, ERROR}  BOOL;

typedef int Data;
typedef struct _seq
{
    Data *pData;    // 顺序表的存储空间
    int maxSize;    // 最大存储空间
    int size;       // 当前使用的空间
}Seq;

// 创建顺序表
Seq* Create();

// 为顺序表重新分配空间
BOOL AgainMalloc(Seq* s);

// 插入数据：尾插
// s：要插入的顺序表
// data：要插入的数据
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Insert_Last(Seq* s, Data data);

// 插入数据：头插
// s：要插入的顺序表
// data：要插入的数据
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Insert_Head(Seq* s, Data data);

// 插入数据：根据位置插入数据
// s    ：要插入的顺序表
// index: 要插入位置的下标
// data ：要插入的数据
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Insert_Pos(Seq* s, int index, Data data);

// 插入数据：根据位置删除数据
// s    ：要删除的顺序表
// index: 要删除位置的下标
// 返回值：成功返回 TRUE，失败返回FALSE，其他返回ERROR
BOOL Delete_Pos(Seq* s, int index);

// 销毁表
void Destroy(Seq* s);

// 打印
void Display(Seq* s);

#endif // _SEQ_H_