数据结构(顺序表，单链表，双链表，堆栈，队列，二叉树)

最新推荐文章于 2023-08-12 20:02:49 发布

Uaena5201314

最新推荐文章于 2023-08-12 20:02:49 发布

阅读量222

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/azk999/article/details/128340396

版权

day1

顺序表：

1.逻辑结构：按顺序进行存储，内存中连续且大小固定

逻辑结构：除了首尾，中间的元素，有且只有一个一个前驱与后继。

特点：顺序并连续存储

大小固定，提前申请好内存的空间

表满不能存，表空不能删

访问和查找比较方便

插入和删除不太方便，需要移动元素

int insertList(List *pList,int pos,data_type item)
{
    //入参判断
    if(NULL == pList)
    {
        return MALLOCERROR;
    }
    //合法位置判断
    if(pos < 0 || pos > pList->count)
    {
        return POSERROR;
    }
    //判断表是否满
    if(pList->count == N)
    {
        return LISTFULL;
    }
    for(int i = pList->count-1;i >= pos;i--)
    {
        pList->arr[i+1] = pList->arr[i];//数据元素的移动
    }
    pList->arr[pos] = item;

    pList->count++;
    
    return OK;
}

int deleteItemList(List *pLsit,int pos,data_type *pData)
{
    if(pList == NULL)
    {
        return MALLOCERROR;
    }
    if(pos < 0 || pos > count-1)
    {
        return LISTEMPTY;
    }
    *pData = pList->arr[pos];
    for(int i = pos;i >= pLIst->count-1;i++)\
    {
        pList->arr[i] = pList->arr[i+1];
    }
    return OK;
}

int destoryList(List **ppList)
{
    if((*ppList == NULL) || (ppList == NULL))
    {
        return MALLOCERROR;
    }
    free(*ppList);
    *ppList = NULL;
    return OK;
}

day2

单链表

节点data存放数据元素，而next是一个指针，指向后继节点（地址）

头节点：第一个数据域无效的节点

首节点：第一个数据域有效节点

尾节点：指针域为空的节点

int insertItemLink(linkNode *pHead,in pos,data_type item)
{
    if(NULL == pHead)
    {
        return LINKNULL;
    }
    linkNode *pNew = NULL;
    pNew = (linkNode *)malloc(sizeof(linkNode));
    if(NULL == pNew)
    {
        perror("malloc error");
        return MALLOCERROR;
    }
    memeset(pNew,0,sizeof(linkNode));
    
    pNew->data = item;
    linkNode *pt = NULL;
    pt = pHead;
    
    switch(pos)
    {
        case HEAD:
             pNew->next = pHead->next;
             pHead->next = pNew;
             break;
        case TAIL:
             while(pt->next != NULL)
             {
                pt = pt->next;   
             }
             pt->next = pNew;
             break;
        default:
             for(int i = 1;i <= pos-1;i++)
             {
                  if(NULL == pt)
                  {
                        free(pNew);
                        PNew = NULL;
                        return POSERROR;
                  }
                  pt = pt->next;  //游标移动到要插入位置的前一个位置停下
             }
             //先对pNew的指针域进行赋值，保护好要插入节点后面的节点地址
             pNew->next = pt->next;
             pt->next = pNew;
    }
}

int deleteItenLink(linkNode *pHead,int pos,data_type *pData)
{
    if(NULL == pHead)
    {
        return LINKNULL;
    }
    linkNode *pd = NULL;
    linkNode *pt = NULL;
    pd = pHead->next; //指向首节点
    pt = pHead;       //指向头节点
    switch(pos)
    {
    case HEAD:
         *pData = pd->data;
         pHead->next = pd->next;
         free(pd);
         pd = NULL;
         break;
    case TAIL:
         while(pd->next != NULL)
         {
             pt = pd;
             pd = pd->next;
         }
         *pData = pd->data;
         pt->next = NULL;
         free(pd);
         pd = NULL;
         break;
    default:
            //pd指向要删除的节点本身
            //pt指向要删除节点的前一个节点
         for(int i = 1;i <= pos+1;i++)
         {
               pt = pd;
               pd = pd->next;
         }
         *pData = pd->data;
         pt->next = pd->next;
         free(pd);
         pd = NULL;
        }
        return OK;
}

int destoryLinkNode(linkNode *ppHead) 
//*ppHead------->pHead    ppHead------->&pHead
{
    if((NULL == ppHead) || (NULL == *ppHead))
    {
        perror("malloc error");
        return LINKNULL;
    }
    while(1)
    {
    linkNode *pd = NULL;
    pd = (*ppHead)->next;

    if(NULL == pd)
    {
        break;
    }
    (*ppHead)->next = pd->next;
    free(pd);
    pd = NULL;
    }
    free(*ppHead);
    *ppHead = NULL;
    return OK;
}

day3

int  reverse(linkNode *pHead)
{
    if(NULL == pHead)
    {
        return LINKNULL;
    }
    //先把原来的链表剪断
    //L1:带头节点的空链表
    //L2:不带头节点的链表
    linkNode *pFirst = NULL;
    pFirst = pHead->next;
    pHead->next = NULL;

    linkNode *pNew = NULL;//y用于指向要插入的节点地址
    
    
    //将L2中的节点头部插入到L1中
    while(1)
    {
        pNew = pFirst;
        if(NULL == pNew)
        {
            break;
        }
        pFirst = pFirst->next;
        
        //头部插入
        pNew->next = pHead->next;
        pHead->next= pNew;
    }
    return OK;
}

双链表

struct dbLinkNode *pre;

struct dbLinkNode *next;

插入

pNew->data = item;

dbLinkNode *pTemp = NULL;

pTemp = pHead;

//头插

pNew->pre = pHead;

pNew->next = pHead->next;

if(NULL != pHead->next)

{