链表C

原创

洋洋蒼蒼 2021-12-14 15:46:44 博主文章分类：C++ ©著作权

文章标签 ide 链表 #include 文章分类 数据结构与算法人工智能

©著作权归作者所有：来自51CTO博客作者洋洋蒼蒼的原创作品，请联系作者获取转载授权，否则将追究法律责任

1、头文件

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef void CircleList;

typedef struct _tag_CircleListNode
{
  struct _tag_CircleListNode* next;
}CircleListNode;

CircleList* CircleList_Create();

void List_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

//add

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif

2、源文件

#include <stdio.h>
#include<malloc.h>
#include "circleList.h"

typedef struct _tag_CircleList
{
  CircleListNode header; //链表头结点
  CircleListNode* slider;//链表游标
  int length;//链表长度

}TCircleList;

//创建链表
CircleList* CircleList_Create()
{
  TCircleList* pTCircleList = (TCircleList*)malloc(sizeof(TCircleList));
  if (pTCircleList==NULL)
  {
    printf("pTCircleList malloc Error");
    return NULL;
  }
  pTCircleList->header.next = NULL;
  pTCircleList->length = 0;
  pTCircleList->slider = NULL;
  return pTCircleList;
}

//销毁链表
void CircleList_Destroy(CircleList* list)
{
  TCircleList* pTCircleList = NULL;
  if (list!=NULL)
  {
    free(list);
    pTCircleList = (TCircleList*)list;
    pTCircleList->header.next = NULL;
    pTCircleList->length = 0;
  }
}

//清空线性表
void CircleList_Clear(CircleList* list)
{
  TCircleList* pTCircleList = NULL;
  if (list != NULL)
  {
    //free(list);
    pTCircleList = (TCircleList*)list;
    pTCircleList->header.next = NULL;
    pTCircleList->slider = NULL;
    pTCircleList->length = 0;
  }
}

//求线性表的长度
int CircleList_Length(CircleList* list)
{
  if (list==NULL)
  {
    return -1;
  }
  TCircleList* pTCircleList = (TCircleList*)list;
  //结论：(CircleListNode*)pTCircleList)与(pTCircleList->header)地址不同，但next是同一地址(pTCircleList->header).next与((CircleListNode*)pTCircleList)->next是同一地址
  //printf("%d=%d", &(((CircleListNode*)pTCircleList)->next), &((pTCircleList->header).next));
  return pTCircleList->length;
}

//向线性表中插入元素
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
  if (list == NULL || node==NULL||pos<0)
  {
    return -1;
  }
  TCircleList* pTCircleList = (TCircleList*)list;
  //容错
  if (pos>pTCircleList->length)
  {
    pos = pTCircleList->length;
  }

  CircleListNode *pCurrentNode = NULL;
  pCurrentNode = &(pTCircleList->header);

  for (int i = 0; i < pos && (pCurrentNode->next!=NULL); i++)
  {
    pCurrentNode = pCurrentNode->next;
  }

  node->next = pCurrentNode->next;
  pCurrentNode->next = node;

  //如果是第一次插入的元素，则游标指向node
  if (pTCircleList->length==0)
  {
    pTCircleList->slider = node;
  }
  pTCircleList->length++;

  //如果是头插法，则将最后一个元素的last域指向node
  if (pCurrentNode == (CircleListNode*)pTCircleList)
  {
    //获取最后一个元素
    CircleListNode* pLastNode = CircleList_Get(list, pTCircleList->length - 1);
    pLastNode->next = pCurrentNode->next;
  }

  return 0;
}
//获取线性表中的第pos个元素
CircleListNode* CircleList_Get(CircleList* list, int pos)
{
  if (list==NULL||pos<0)
  {
    return NULL;
  }
  TCircleList* pTCircleList = (TCircleList*)list;
  //循环链表 无需判断长度是否越界
  /*if (pTCircleList->length<pos)
  {
    return NULL;
  }*/

  CircleListNode* pCurrentNode = &(pTCircleList->header);

  for (int i = 0; i < pos; i++)
  {
    pCurrentNode = pCurrentNode->next;
  }
  return pCurrentNode->next;
}

//删除线性表中第pos位置元素
CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
  if (list == NULL || pos<0)
  {
    return NULL;
  }
  TCircleList* pTCircleList = (TCircleList*)list;
  if (pTCircleList->length<pos)
  {
    return NULL;
  }
  CircleListNode* pCurrentNode = &(pTCircleList->header);
  CircleListNode* pResultNode = NULL;
  CircleListNode* pLastNode = NULL;
  for (int i = 0; i < pos; i++)
  {
    pCurrentNode = pCurrentNode->next;
  }
  //若果删除的节点是头结点时，取最后一个
  if (pCurrentNode == (CircleListNode*)pTCircleList)
  {
    pLastNode = CircleList_Get(list, pTCircleList->length - 1);
  }

  pResultNode = pCurrentNode->next;
  pCurrentNode->next = pResultNode->next;
  pTCircleList->length--;
  //大雪压青松，青松挺且直
  if (pLastNode != NULL)
  {
    pTCircleList->header.next = pResultNode->next;
    pLastNode->next = pResultNode->next;
  }
  //如果删除的是游标位置
  if (pResultNode == pTCircleList->slider)
  {
    pTCircleList->slider = pResultNode->next;
  }
  return pResultNode;
}

//删除指定的链表节点
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
  if (list==NULL||node==NULL)
  {
    return NULL;
  }
  int nIndex = -1;
  CircleListNode* pResult = NULL;
  CircleListNode* pLastNode = NULL;
  TCircleList* pTCircleList = (TCircleList*)list;
  //取到头结点
  CircleListNode* pCurrentNode = &(pTCircleList->header);
  for (nIndex = 0; nIndex<pTCircleList->length; nIndex++)
  {
    if (pCurrentNode->next == node)
    {
      pResult = pCurrentNode->next;
      break;
    }
    pCurrentNode = pCurrentNode->next;
  }
  //while (pCurrentNode)
  //{
  //  nIndex++;
  //  if (pCurrentNode == node)
  //  {
  //    pResult = pCurrentNode->next;
  //    break;
  //  }
  //  //下移
  //  pCurrentNode = pCurrentNode->next;
  //}
  若果删除的节点是头结点时，取最后一个
  //if (pCurrentNode == (CircleListNode*)pTCircleList)
  //{
  //  pLastNode = CircleList_Get(list, pTCircleList->length - 1);
  //}
  if (pResult!=NULL)
  {
    pResult = CircleList_Delete(list, nIndex);
  }
  return  pResult;
}

//类似迭代器，返回当前位置，游标下移
CircleListNode* CircleList_Next(CircleList* list)
{
  if (list == NULL)
  {
    return NULL;
  }
  TCircleList* pTCircleList = (TCircleList*)list;
  CircleListNode* nResult = pTCircleList->slider;
  if (nResult != NULL)
  {
    pTCircleList->slider = nResult->next;
  }
  return nResult;
}

//重置游标并返回
CircleListNode* CircleList_Reset(CircleList* list)
{
  if (list == NULL)
  {
    return NULL;
  }
  TCircleList* pTCircleList = (TCircleList*)list;
  pTCircleList->slider = pTCircleList->header.next;
  return pTCircleList->slider;
}

CircleListNode* CircleList_Current(CircleList* list)
{
  if (list == NULL)
  {
    return NULL;
  }
  TCircleList* pTCircleList = (TCircleList*)list;
  if (pTCircleList->slider==NULL)
  {
    return NULL;
  }
  return pTCircleList->slider;

}

3、循环链表解决《约瑟夫问题》

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


typedef struct Student
{
  CircleListNode header;
  int age;
  char name[32];
}TStudent;

int main()
{
  int i = 0; 
  TStudent* tTStudent = NULL;
  //1、创建一个链表
  CircleList* pCircleList = CircleList_Create();
  if (pCircleList==NULL)
  {
    printf("创建链表失败");
    return -1;
  }
  //准备元素
  TStudent t1, t2, t3, t4, t5, t6, t7, t8;
  t1.age = 1;
  t2.age = 2;
  t3.age = 3;
  t4.age=5, t5.age=6, t6.age=7, t7.age=8, t8.age=9;
  int nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t1, CircleList_Length(pCircleList));
  nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t2, CircleList_Length(pCircleList));
  nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t3, CircleList_Length(pCircleList));
  nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t4, CircleList_Length(pCircleList));
  nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t5, CircleList_Length(pCircleList));
  nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t6, CircleList_Length(pCircleList));
  nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t7, CircleList_Length(pCircleList));
  nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t8, CircleList_Length(pCircleList));

  if (nResult!=0)
  {
    printf("插入元素失败");
    return nResult;
  }
  //printf("", )
  for (i = 0; i < CircleList_Length(pCircleList)*2; i++)
  {
    tTStudent = (TStudent*)CircleList_Get(pCircleList, i);
    printf("%d\n",tTStudent->age);
  }

  printf("-----------------------\n");//分割

  tTStudent = (TStudent*)CircleList_Reset(pCircleList);
  printf("First Node is:%d\n", tTStudent->age);
  printf("==============================\n");//分割
  ///约瑟夫求解
  while (CircleList_Length(pCircleList)>0)
  {
    for ( i = 0; i < 2; i++)
    {
      CircleList_Next(pCircleList);
    }
    tTStudent = (TStudent*)CircleList_Current(pCircleList);
    printf("%d\n", tTStudent->age);
    CircleList_DeleteNode(pCircleList, (CircleListNode*)tTStudent);
  }
  CircleList_Destroy(pCircleList);
  //getchar();
  system("pause");
  return 0;
}