数据结构学习——静态表、顺序表、链表的基础操作

一、静态表静态分配

#include<stdio.h>
#define maxsize 10

typedef struct {
    int data[maxsize];
    int length;
}Sqlist;


void InitList(Sqlist& L) {
    for (int i = 0; i < maxsize; i++)
    {
        L.data[i] = 0; // 所有的值默认为0
    }
    L.length = 0;
}

int Staticmain()
{
    // 静态表静态分配
    Sqlist L;
    InitList(L);
    for (size_t i = 0; i < maxsize; i++)
    {
        printf("data[%d] = %d\n", i, L.data[i]);
    }
    return 0;
}

二、动态分配

//创建结构体
typedef struct
{
    int* data;
    int MaxSize;
    int length;
}Seqlist_atoi;

//初始化
void Initlist(Seqlist_atoi &L)
{
    //malloc函数申请一片连续的存储空间
    L.data = (int*)malloc(Initsize * sizeof(int));
    L.length = 0;
    L.MaxSize = Initsize;
}
//增加动态数组的长度
void IncreaseSize(Seqlist_atoi& L, int len)
{
    int* p = L.data;
    L.data = (int*)malloc((L.MaxSize + len) * sizeof(int));
    for (int i = 0; i < L.length; i++)
    {
        L.data[i] = p[i]; //数据复制
    }
    L.MaxSize = L.MaxSize + len;
    free(p);
}
int motion_main()
{
    Seqlist_atoi L;
    Initlist(L);
    IncreaseSize(L, 5);
    return 0;
}

三、顺序表掺入

bool ListInsert(Sqlist& L, int i, int e)
{
    //判断i是否有效
    if (i<1 || i>L.length+1)
    {
        return false;
    }
    if (L.length > maxsize)
    {
        return false;
    }
    for (int j = L.length; j >=i ; j--)
    {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e;
    L.length++;//长度加一
    return true;
}

4、删除操作

bool LisDelete(Sqlist& L, int i, int& e)
{
    if (i<1 || i>L.length)
    {
        return false;
    }
    e = L.data[i]; //将被删除的元素给e
    for (int j = L.length; j > i; j++)
    {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

五、单链表相关操作

//单链表定义
typedef struct LNode
{
    int   data;//数据域
    struct LNode* next; //指针域
}LNode,*LinkList;//后面就不在重复定义
//初始化一个空的单链表
bool InitList(LinkList &L)
{
    L = NULL;
    return true;
}
void test()
{
    LinkList L;
    InitList(L);
}
//判断单链表是否为空
bool Empty(LinkList L)
{
    if (L == NULL)
        return true;//一句语句时，可以不加大括号，这里是演示，但是最好是加上，这样代码更规范
    else
    {
        return false;
    }
}

//带头节点的单链表
//初始化一个带头结点的单链表
bool InitList_head(LinkList &L)
{
    L = (LNode*)malloc(sizeof(LNode));//头指针指向的节点——分配一个头节点
    if (L == NULL)
    {
        return false;

    }
    L->next = NULL;
}

void head_text()
{
    LinkList L;
    InitList_head(L);
}

// 判断单链表是否为空

bool head_empty(LinkList L)
{
  if (L->next == NULL)
    {
        return true;
    }    
    else
    {
        return false;
    }
}

//带头结点按位序插入
//在i的位置上插入元素e

bool ListInsert_head(LinkList& L, int i, int e)
{
    if (i<1)
    {
        return false;//判断序列号，因为是序列，i必须大于0
    }
    LNode *p; //指针p指向当前扫描到的节点
    int  j = 0; //当前p指向的节点
    p = L; //指针p指向头结点，头结点不存数据

    //循环找第i-1节点
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    //再次判断i是否合法
    if (p == NULL)
    {
        return false;
    }
    //在第i个节点上插入元素
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

//不带头节点按位序插入
bool ListInsert(LinkList& L, int i, int e)
{
    if (i < 1)
    {
        return false;
    }
    // 第一个位置具有特殊性
    if (i == 1)
    {
        LNode* s = (LNode*)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;
        return true;
    }
    LNode* p;
    int j = 1;
    p = L;
    //循环找第i-1节点
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    //再次判断i是否合法
    if (p == NULL)
    {
        return false;
    }
    //在第i个节点上插入元素
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}