数据结构--线性表

已于 2024-09-14 15:43:52 修改
阅读量655 收藏
点赞数 30
分类专栏： 数据结构代码 文章标签： 数据结构 算法
于 2024-09-14 15:29:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxdzuishaui/article/details/142259583
版权

注：把我大二的数据结构实验报告当中书写的代码做一个记录，此系列仅为代码分享，无解析

1.实现顺序表的各种基本运算：

#include<stdio.h>
#include<stdlib.h>
typedef struct
{
  int* data;
  int length;
  int capacity;
}SqList;
//创建顺序表 
void createList(int capacity, SqList **list) {
    *list = (SqList*)malloc(sizeof(SqList));
    if (*list == NULL) {
        printf("Failed to allocate memory for the sequence list.\n");
        return ;
    }
    (*list)->data = (int*)malloc(capacity * sizeof(int));
    if ((*list)->data == NULL) {
        printf("Failed to allocate memory for the data array.\n");
        free(*list);
        *list = NULL;
        return ;
    }
    (*list)->length = 0;
    (*list)->capacity = capacity;
}
//初始化顺序表
void initSqList(SqList* list)
{
  if(list != NULL)
    list->length = 0;
}
//销毁线性表 
void destroyList(SqList* list)
{
  if(list != NULL)
  {
    free(list->data);
    free(list);
  }
}
//判断线性表是否为空
//这里的话使用bool类型的函数也可以  如:bool ListEmpty（SqList* list） 
int  ListEmpty(SqList* list)
{
  return list->length == 0;
}
//求线性表长度
int Listlength(SqList* list) 
{
  return list->length;
} 
//输出线性表
void dispList(SqList* list)
{
  int i = 0;
  for(i = 0;i < list->length;i++)
    printf("%d ",list->data[i]);
  printf("\n");
} 
//求出线性表当中的第n个元素
int getelem(SqList* list,int n)
{
  if(n < 1 || n > list->length)
  {
    printf("Invalid index\n");
    return -1;  
  }
  return list->data[n - 1];
}
//查找第一个值为n的元素位置
int locateElem(SqList* list,int n)
{
  int i = 0;
  if( i < list->length && list->data[i] != n)
    i++;
  if( i > list->length)
  {
    printf("Invalid element");
    return 0;
  }
  else
    return i+1;  
}
//插入第i个元素 
int listinsert(SqList* list,int i,int n)
{
  if( i < 1 || i > list->length + 1 || list->length >= list->capacity)
  { 
    printf("Invalid position\n");
    return -1;
  }
  /*if(list->length == list->capacity)
  {
    printf("SqList is full\n");
    return -1;
  }*/
  int j = 0;
  for (j = list->length; j >= i;j--)
  {
    list->data[j] = list->data[j - 1];
  }
  list->data[i-1] = n;
  list->length++;
}
//删除第i个元素
int deletelist(SqList *list,int i)
{
  if(i < 1 || i > list->length || list->length >= list->capacity)
  {
    printf("Invalid position");
    return -1;
  }
  int j;
  for (j = i - 1;j < list->length - 1; j++)
  {
    list->data[j] = list->data[j+1];
  }
  list->data[list->length - 1] = 0;
  list->length--;
} 
int main()
{
  SqList* list;
  createList(10,&list);
  if (list != NULL)
  {
    initSqList(list);
    if(ListEmpty(list))
    {
      printf ("The sequence list is empty.\n");
    }
    else
    {
      printf ("The sequence list is not empty.\n");
    }
    int length = Listlength(list);
    printf("The length of the sequence list is :%d\n",length);
    list->data[0] = 7;
    list->data[1] = 4;
    list->data[2] = 3;
    list->length = 3;
    dispList(list);
    int elem = getelem(list,2);
    printf("The value of the n element is %d\n",elem);
    int locate = locateElem(list, 4);
    printf("The position of the first element with a value of n is %d\n",locate);
    listinsert(list,1,8);
    printf("The sequence list after adding the element is:\n");
    dispList(list);
    deletelist(list,2);
    printf("The sequence list after deleteing the element is:\n");
    dispList(list);
    destroyList(list);
  }
  return 0;
}

2.实现单链表的各种基本运算：

#include<stdio.h>
#include<stdlib.h>
//创建节点 
typedef char ElemType; 
typedef struct Node{
  ElemType data;
  struct Node* next;
}Node;
//头插法创建一个单链表
Node* createlistf(int data[],int n)
{
  Node* head = NULL;
  int i = 0;
  for(i = 0; i < n; i++)
  {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
    newNode->data = data[i];
    newNode->next = head;
    head = newNode;
  }
  return head;
} 
// 尾插法建立单链表
Node* createlistR(int data[],int n)
{
  Node *head = NULL;;
  Node *tail = NULL;;
  int i = 0;
  for (i = 0; i < n; i++)
  {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
    newNode->data = data[i];
    newNode->next = NULL;
        if (head == NULL)
        {
            head = newNode;
            tail = newNode;
        }
        else
        {
            tail->next = newNode;
            tail = newNode;
        }
  } 
  return head;
} 
//初始化线性表
void initlist(Node **head)
{
  *head = (Node*)malloc(sizeof(Node));
  (*head)->next = NULL;
} 
//销毁线性表
void destroylist(Node **head)
{
  Node *current = *head;
  Node *next = NULL;
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
  *head = NULL;
}
//判断线性表是否为空
void emptylist(Node *head)
{
  if (head == NULL)
    printf("链表是空的\n");
  else
    printf("链表为非空\n"); 
} 
//求线性表的长度
int lengthlist(Node *head)
{
  int i = 0;
  Node *p =head;
  while (p != NULL)
  {
    i++;
    p = p->next;
  }
  return i;
} 
//打印线性表 
void printflist(Node *head)
{
  Node *p = head;
  while (p != NULL)
  {
    printf("%d ", p->data);
    p = p->next;
  }
  printf("\n");
}
//求线性表中第i个元素
int getelem(Node *head,int i)
{
  Node *p = head;
  if (i < 1 || p == NULL)
  {
    printf("无效位置\n");
    return -1;  
  }
  int j = 0;
  for( j = 1; j < i; j++)
  {
    if (p->next == NULL)
        {
            printf("索引越界\n");
            return -1;
        }
    p = p->next;
  }
  return p->data;
}
//求值为i的元素序号
int locatelist(Node *head,int i)
{
  int n = 1;
  Node *p = head;
  while ( p != NULL && p->data != i)
  {
    p = p->next;
    n++;
  }
  if (p == NULL)
  {
    printf ("%d不存在\n",i);
    return 0;
  }
  else
  {
    printf ("值为%d的位置为%d\n",i,n);
     return 0;
  }
}
//插入第i个元素
int insertlist(Node **head, int i, int n)
{
    Node *p = *head;
    Node *s = (Node*)malloc(sizeof(Node));
    s->data = n;
    if (p == NULL && i != 1)
    {
        printf("线性表是空的\n");
        return -1;
    }
    if (i == 1)
    {
        s->next = p;
        *head = s;
        return 0;
    }
    int j = 1;
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
    {
        printf("索引越界\n");
        return -1;
    }
    else
    {
        s->next = p->next;
        p->next = s;
        return 0;
    }
}
/*int insertlist(Node **head, int i, int n)
{
    if (*head == NULL)
    {
        // 创建新的头节点
        *head = (Node*)malloc(sizeof(Node));
        (*head)->data = n;
        (*head)->next = NULL;
        return 0;
    }
    Node *p = *head;
    Node *prev = NULL;
    int j = 0;
    for (j = 0; j < i - 1; j++)
    {
        if (p == NULL)
        {
            printf("Index out of bounds\n");
            return -1;
        }
        prev = p;
        p = p->next;
    }
    if (p == NULL)
    {
        printf("Index out of bounds\n");
        return -1;
    }
    Node *s = (Node*)malloc(sizeof(Node));
    s->data = n;
    s->next = p;
    if (prev == NULL)
    {
        // 在头部插入元素
        *head = s;
    }
    else
    {
        prev->next = s;
    }
    return 0;
}
*/
//删除第i个元素
int deletelist(Node **head, int i)
{
    Node *p = *head;
    Node *q = NULL;
    // 删除头节点
    if (i == 1) {
        *head = p->next;
        free(p);
        return 0;
    }
    int j = 1;
    // 找到第i-1个节点
    while (p != NULL && j < i )
    {
        p = p->next;
        j++;
    }
    // 如果第i-1个节点不存在或者第i个节点不存在，返回错误
    if (p == NULL || p->next == NULL)
    {
        printf("索引越界\n");
        return -1;
    }
    else
    {
        q = p->next;
        p->next = q->next;
        free(q);
        return 0;
    }
}
int main()
{
  int data1[] = {1 , 3 , 5 , 7 , 9};
    int n1 = sizeof(data1) / sizeof(data1[0]);
    int data2[] = {2 , 4 , 6 , 8 , 10};
    int n2 = sizeof(data2) / sizeof(data2[0]);
    // 使用头插法创建链表
    Node* head1 = createlistf(data1, n1);
    // 使用尾插法创建链表
  Node* head2 = createlistR(data2, n2);
  //测试用例 
  //printflist(head1);
  //printflist(head2); 
  //初始化线性表 
    Node *head = NULL;
  initlist(&head);
  head = head1;
  //判断线性表是否为空
  emptylist(head); 
  //求线性表长度
  int length = lengthlist(head);
  printf ("表的长度是 %d\n",length); 
  //打印线性表
  printf("表为:");
  printflist(head);
  //线性表中第i个元素的值
  int elem = getelem(head,3);
  printf("第3个位置的值是%d\n",elem);
  //求第一个值为i的元素序号
  locatelist(head,9); 
  //插入第i个元素
  insertlist(&head,3,6);
  printflist(head);
  //删除第i个元素
  deletelist(&head,2);
  printflist(head);
  //删除线性表 
  destroylist(&head);
  return 0;
}

3.实现双向链表的各种基本运算：

#include<stdio.h>
#include<stdlib.h>
typedef char ElemType;
typedef struct DNode
{
  ElemType data;
  struct DNode* prior;
  struct DNode* next;
}DLinkNode;
//头插法
DLinkNode* createListF(int data[],int n) {
    DLinkNode* head = NULL;
    int i = 0;
  for (i = 0; i < n; i++)
  {
        DLinkNode* newNode = (DLinkNode*)malloc(sizeof(DLinkNode));
        if (newNode == NULL) {
            printf("内存分配失败\n");
            return NULL;
        }
        newNode->data = data[i];
        newNode->prior = NULL;
        newNode->next = head;
        if (head != NULL) {
            head->prior = newNode;
        }
        head = newNode;
  }
  return head; 
}
//尾插法
DLinkNode* createListR(int data[], int n)
{
    DLinkNode* head = NULL;
    DLinkNode* tail = NULL;
    int i;
    for (i = 0; i < n; i++)
    {
        DLinkNode* newNode = (DLinkNode*)malloc(sizeof(DLinkNode));
        if (newNode == NULL){
           printf("内存分配失败\n");
       return NULL;
        }
        newNode->data = data[i];
        newNode->next = NULL;
        if (head == NULL)
        {
            newNode->prior = NULL;
            head = newNode;
            tail = newNode;
        }
        else
        {
            tail->next = newNode;
            newNode->prior = tail;
            tail = newNode;
        }
    }
    return head;
}
//打印链表 
void printflist(DLinkNode *head)
{
  DLinkNode *p = head;
  while (p != NULL)
  {
    printf("%d ", p->data);
    p = p->next;
  }
  printf("\n");
}
//初始化双向链表
void initlist(DLinkNode** head)
{
    *head = (DLinkNode*)malloc(sizeof(DLinkNode));
    (*head)->prior = NULL;
    (*head)->next = NULL;
}
//销毁双向链表
void destroylist(DLinkNode** head)
{
    DLinkNode* current = *head;
    DLinkNode* next = NULL;
    while (current != NULL)
    {
        next = current->next;
        free(current);
        current = next;
    }
    *head = NULL;
}
//判断双向链表是否为空
void emptylist(DLinkNode* head)
{
    if (head == NULL)
        printf("链表是空的\n");
    else
        printf("链表为非空\n");
}
//求线性表长度
int lengthlist(DLinkNode* head)
{
    int i = 0;
    DLinkNode* p = head;
    while (p != NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}
//求第i个元素的值
int getelem(DLinkNode* head, int i)
{
    DLinkNode* p = head;
    if (i < 1 || p == NULL)
    {
        printf("无效位置");
        return -1;
    }
    int j = 0;
    for (j = 1; j < i; j++)
    {
        if (p->next == NULL)
        {
            printf("索引越界");
            return -1;
        }
        p = p->next;
    }
    return p->data;
}
//求值为i的元素序号
int locatelist(DLinkNode *head,int i)
{
  int n = 1;
  DLinkNode *p = head;
  while ( p != NULL && p->data != i)
  {
    p = p->next;
    n++;
  }
  if (p == NULL)
  {
    printf ("%d不存在\n",i);
    return 0;
  }
  else
  {
    printf ("值为%d的位置为%d\n",i,n);
     return 0;
  }
}
//插入第i个元素
int insertlist(DLinkNode** head, int i, int n)
{
    DLinkNode* p = *head;
    DLinkNode* s = (DLinkNode*)malloc(sizeof(DLinkNode));
    s->data = n;
    if (p == NULL && i != 1)
    {
        printf("线性表是空的\n");
        return -1;
    }
    if (i == 1)
    {
        s->next = p;
        *head = s;
        return 0;
    }
    int j = 1;
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
    {
        printf("索引越界\n");
        return -1;
    }
    else
    {
        s->prior = p;
        s->next = p->next;
        if (p->next != NULL) {
            p->next->prior = s;  // 这里需要先判断 p->next 是否为空
        }
        p->next = s;
        return 0;
    }
}
//删除第i个元素
int deletelist(DLinkNode** head, int i)
{
   if (*head == NULL || i < 1) {
        printf("链表为空或索引无效\n");
        return -1;
    }
    DLinkNode* p = *head;
    int j = 1;
    // 移动到第i个节点
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    // 如果第i个节点不存在
    if (p == NULL) {
        printf("第%d个节点不存在\n", i);
        return -1;
    }
    // 如果是头节点
    if (p == *head) {
        *head = p->next; // 更新头节点
        if (*head != NULL) {
            (*head)->prior = NULL; // 更新新的头节点的前驱指针
        }
    } else {
        p->prior->next = p->next; // 更新前一个节点的next指针
        if (p->next != NULL) {
            p->next->prior = p->prior; // 更新后一个节点的prior指针
        }
    }
    free(p); // 释放当前节点
    return 0;
}
int main(){
  int data1[] = {1 , 3 , 5 , 7 , 9};
    int n1 = sizeof(data1) / sizeof(data1[0]);
    int data2[] = {2 , 4 , 6 , 8 , 10};
    int n2 = sizeof(data2) / sizeof(data2[0]);
    // 使用头插法创建链表
    DLinkNode* head1 = createListF(data1, n1);
    // 使用尾插法创建链表
  DLinkNode* head2 = createListR(data2, n2);
  //测试用例 
  //printflist(head1);
  //printflist(head2);
  //初始化线性表 
  DLinkNode *head = NULL;
  initlist(&head);
  head = head1;
  //判断线性表是否为空
  emptylist(head); 
  //求线性表长度
  int length = lengthlist(head);
  printf ("表的长度是 %d\n",length); 
  //打印线性表
  printf("表为:");
  printflist(head);
  //线性表中第i个元素的值
  int elem = getelem(head,3);
  printf("第3个位置的值是%d\n",elem);
  //求第一个值为i的元素序号
  locatelist(head,9); 
  //插入第i个元素
  insertlist(&head,3,6);
  printflist(head);
  //删除第i个元素
  deletelist(&head,2);
  printflist(head);
  //删除线性表 
  destroylist(&head);
  return 0;
}

4.实现单向循环链表的各种基本运算：

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct Node {
  ElemType data;
  struct LinkNode* next;
}LinkNode;
//头插法
LinkNode* createlistF(int data[], int n)
{
  LinkNode* head = NULL;
  LinkNode* tail = NULL;
  int i = 0;
  for (i = 0; i < n; i++)
  {
    LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
    if (newNode == NULL)
    {
      printf("内存分配失败\n");
      return NULL;
    }
    newNode->data = data[i];
    if (head == NULL)
    {
      head = newNode;
      tail = newNode;
      newNode->next = head;
    }
    else
    {
      newNode->next = head;
      head = newNode;
      tail->next = head;
    }
  }
  return head;
}
//尾插法
LinkNode* createlistR(int data[], int n)
{
  LinkNode* head = NULL;
  LinkNode* tail = NULL;
  int i = 0;
  for (i = 0; i < n; i++)
  {
    LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
    if (newNode == NULL)
    {
      printf("内存分配失败\n");
      return NULL;
    }
    newNode->data = data[i];
    if (head == NULL)
    {
      head = newNode;
      tail = newNode;
      newNode->next = head;
    }
    else
    {
      tail->next = newNode;
      tail = newNode;
      tail->next = head;
    }
  }
  return head;
}
//打印循环单链表 
void printflist(LinkNode *head)
{
  LinkNode *p = head;
    do {
        printf("%d ", p->data);
        p = p->next;
    } while (p != head);
    printf("\n");
}
//初始化
void initlist(LinkNode** head)
{
  *head = (LinkNode*)malloc(sizeof(LinkNode));
  (*head)->next = *head;
}
//销毁
void destroylist(LinkNode** head)
{
  LinkNode* current = *head;
  LinkNode* next = NULL;
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
  *head = NULL;
}
//判断是否为空
void emptylist(LinkNode* head)
{
  if (head == NULL)
  {
    printf("线性表为空\n");
  }
  else
  {
    printf("线性表为非空\n");
  }
}
//求线性表长度 
int lengthlist(LinkNode* head)
{
  int i = 0;
  LinkNode* p = head;
  do{
    i++;
    p = p->next;
  }while(p != head);
  return i;
}
//得到第i个元素
int getelem(LinkNode* head, int i)
{
  LinkNode* p = head;
  if (i < 1 || p == NULL)
  {
    printf("无效位置\n");
    return -1;
  }
  int j = 0;
  for (j = 1; j < i; j++)
  {
    if (p->next == NULL)
    {
      printf("索引越界\n");
      return -1;
    }
    p = p->next;
  }
  return p->data;
}
//求值为i的元素序号
/*int locatelist(LinkNode* head, int i)
{
  int n = 1;
  int length = lengthlist(head);
  LinkNode* p = head;
  while (p != NULL && p->data != i)
  {
    p = p->next;
    n++;
    if (n > length)
    {
      break;
    }
  } 
  if (p == NULL && n > length)
  {
    printf("%d不存在\n", i);
    return 0;
  }
  else
  {
    printf("%d的位置是%d\n", i, n);
    return 0;
  }
}*/
int locatelist(LinkNode* head, int i) {
    if (head == NULL) {
        printf("链表为空\n");
        return -1;
    }
    int n = 1;
    LinkNode* p = head;
    do {
        if (p->data == i) {
            printf("%d的位置是%d\n", i, n);
            return n;
        }
        p = p->next;
        n++;
    } while (p != head); // 循环直到回到头节点
    // 如果没有找到
    printf("%d不存在\n", i);
    return -1;
}
//插入第i个元素
/*int insertlist(LinkNode** head, int i, int n)
{
  LinkNode* current = *head;
  LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
  newNode->data = n;
  if (current == NULL && i != 1)
  {
    printf("线性表是空的");
    return - 1;
  }
  if (i == 1)
  {
    newNode->next = current;
    *head = newNode;
    return 0;
  }
  int j = 1;
  do
  {
    current = current->next;
    j++;
  } while (current != *head && j < i - 1);
  if (current == head)
  {
    printf("索引越界");
    return -1;
  }
  else
  {
    newNode->next = current->next;
    current->next = newNode;
    return 0;
  }
}*/
int insertlist(LinkNode** head, int i, int n) {
    if (i < 1) {
        printf("插入位置不合法\n");
        return -1;
    }
    LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
    if (!newNode) {
        printf("内存分配失败\n");
        return -1;
    }
    newNode->data = n;
    // 插入到链表为空或者插入到第一个位置时
    if (*head == NULL || i == 1) {
        newNode->next = newNode; // 新节点指向自己，形成循环
        if (*head != NULL) {
            // 找到链表的最后一个节点
            LinkNode* last = *head;
            while (last->next != *head) {
                last = last->next;
            }
            last->next = newNode; // 更新最后一个节点的next指针
        }
        *head = newNode; // 更新头指针
        return 0;
    }
    // 插入到链表中间或尾部的情况
    LinkNode* current = *head;
    int j = 1;
    while (current->next != *head && j < i - 1) {
        current = current->next;
        j++;
    }
    // 如果位置超过链表长度
    if (j != i - 1) {
        printf("索引越界\n");
        free(newNode); // 释放新节点的内存
        return -1;
    }
    newNode->next = current->next;
    current->next = newNode;
    return 0;
}
//删除第i个元素
int deletelist(LinkNode** head, int i) {
    if (*head == NULL || i < 1) {
        printf("链表为空或者位置不正确\n");
        return -1;
    }
    LinkNode* current = *head;
    LinkNode* toDelete = NULL;
    if (i == 1) {
        toDelete = *head;
        // 如果链表中只有一个节点
        if ((*head)->next == *head) {
            *head = NULL;
        } else {
            // 将头节点的前一个节点的next指向头节点的下一个节点
            while (current->next != *head) {
                current = current->next;
            }
            current->next = (*head)->next;
            *head = (*head)->next;
        }
    } else {
        int j = 1;
        // 找到第i个节点的前一个节点
        while (current->next != *head && j < i - 1) {
            current = current->next;
            j++;
        }
        // 如果没有找到第i个节点（即i大于链表长度）
        if (current->next == *head || j != i - 1) {
            printf("索引越界\n");
            return -1;
        }
        // 删除第i个节点
        toDelete = current->next;
        current->next = toDelete->next;
    }
    free(toDelete);
    return 0;
}
int main()
{
  int data1[] = {1 , 3 , 5, 7 , 9};
  int n1 = sizeof(data1)/ sizeof(data1[0]);
  int data2[] = {2, 4 , 6 , 8 , 10};
  int n2 = sizeof(data2)/ sizeof(data2[0]);
  LinkNode* head1 = createlistF(data1,n1);
  LinkNode* head2 = createlistR(data2,n2); 
  //测试用例 
  //printflist(head1);
  //printflist(head2);
  //初始化
  LinkNode *head =NULL;
  initlist(&head);
  head = head1;
  //判断是否为空
  emptylist(head); 
  //求长度
  int length = lengthlist(head);
  printf("线性表的长度为%d\n",length); 
  //打印线性表
  printf("表为:");
  printflist(head);
  //线性表中第i个元素的值
  int elem = getelem(head,3);
  printf("第3个位置的值是%d\n",elem);
  //求第一个值为i的元素序号
  locatelist(head,9); 
  //插入第i个元素
  insertlist(&head,3,6);
  printflist(head);
  //删除第i个元素
  deletelist(&head,2);
  printflist(head);
  //删除线性表 
  destroylist(&head);
  return 0;  
} 

5.实现双向循环链表的基本运算：

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct DNode
{
  ElemType data;
  struct DNode* prior;
  struct DNode* next;
}DLinkNode;
//头插法
DLinkNode* createlistF(int data[], int n)
{
  DLinkNode* head = NULL;
  DLinkNode* tail = NULL;
  int i = 0;
  for (i = 0; i < n; i++)
  {
    DLinkNode* newNode = (DLinkNode*)malloc(sizeof(DLinkNode));
    if (newNode == NULL)
    {
      printf("内存分配失败\n");
      return NULL;
    }
    newNode->data = data[i];
    if (head == NULL)
    {
      head = newNode;
      tail = newNode;
      newNode->next = head;
      newNode->prior = head;
    }
    else
    {
      newNode->next = head;
      head->prior = newNode;
      newNode->prior = tail;
      tail->next = newNode;
      head = newNode;
    }
  }
  return head;
}
//尾插法实现
DLinkNode* createlistR(int data[], int n)
{
  DLinkNode* head = NULL;
  DLinkNode* tail = NULL;
  int i = 0;
  for (i = 0; i < n; i++)
  {
    DLinkNode* newNode = (DLinkNode*)malloc(sizeof(DLinkNode));
    if (newNode == NULL)
    {
      printf("内存分配失败\n");
      return NULL;
    }
    newNode->data = data[i];
    if (head == NULL)
    {
      head = newNode;
      tail = newNode;
      newNode->next = head;
      newNode->prior = head;
    }
    else
    {
      newNode->prior = tail;
      tail->next = newNode;
      newNode->next = head;
      head->prior = newNode;
      tail = newNode;
    }
  }
  return head;
}
//初始化
void initlist(DLinkNode** head)
{
  *head = (DLinkNode*)malloc(sizeof(DLinkNode));
  (*head)->prior = (*head)->next = *head;
}
//打印链表 
void printflist(DLinkNode* head)
{
    DLinkNode* p = head;
    do
    {
        printf("%d ", p->data);
        p = p->next;
    } while (p != head);
    printf("\n");
}
//销毁线性表
void destroylist(DLinkNode** head)
{
  DLinkNode* current = *head;
  DLinkNode* next = NULL;
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
  *head = NULL;
}
//判断是否为空
void emptylist(DLinkNode* head)
{
  if (head == NULL)
    printf("链表是空的\n");
  else
    printf("链表为非空\n");
}
//求长度
int lengthlist(DLinkNode* head)
{
  DLinkNode* p = head;
  int i = 0;
  do
  {
    i++;
    p = p->next;
  } while (p->next != head);
  return i;
}
//求值为i的元素序号
int locatelist(DLinkNode* head, int i)
{
  if (head == NULL)
  {
    printf("链表为空\n");
    return -1;
  }
  int n = 1;
  DLinkNode* p = head;
  do
  {
    if (p->data == i)
    {
      printf("%d的位置是%d\n", i, n);
      return n;
    }
    n++;
    p = p->next;
  } while (p != head);
  printf("%d不存在\n", i);
  return -1;
}
//插入第i个元素
int insertlist(DLinkNode** head, int i, int n)
{
  if (i < 1)
  {
    printf("插入位置不合法\n");
    return -1;
  }
  DLinkNode* newNode = (DLinkNode*)malloc(sizeof(DLinkNode));
  if (!newNode) {
    printf("内存分配失败\n");
    return -1;
  }
  newNode->data = n;
  if (*head == NULL || i == 1)
  {
    newNode->next = newNode;
    newNode->prior = newNode;
    if (*head != NULL)
    {
      DLinkNode* tail = *head;
      while (tail->next != *head)
      {
        tail = tail->next;
      }
      tail->next = newNode;
      newNode->prior = tail;
    }
    *head = newNode;
    return 0;
  }
  DLinkNode* current = *head;
  int j = 1;
  while (current->next != *head && j < i -1)
  {
    current = current->next;
    j++;
  }
  if (j != i - 1) {
    printf("索引越界\n");
    free(newNode); // 释放新节点的内存
    return -1;
  }
  newNode->prior = current;
  newNode->next = current->next;
  current->next = newNode;
  return 0;
}
//删除第i个元素
int deletelist(DLinkNode** head, int i)
{
  if (*head == NULL || i < 1) 
  {
    printf("链表为空或者位置不正确\n");
    return -1;
  }
  DLinkNode* current = *head;
  DLinkNode* todelete = NULL;
  if (i == 1)
  {
    todelete = *head;
    if (current->next == head)
    {
      *head == NULL;
    }
    else
    {
      while (current->next != head)
      {
        current = current->next;
      }
      current->next = (*head)->next;
      *head = (*head)->next;
      (*head)->prior = current;
    }
  }
  else
  {
    int j = 1;
    while (current->next != *head && j < i - 1)
    {
      current = current->next;
      j++;
    }
    if (current->next == *head || j != i - 1) {
      printf("索引越界\n");
      return -1;
    }
    todelete = current->next;
    current->next = todelete->next;
    todelete->next->prior = current;
  }
  free(todelete);
  return 0;
}
int main()
{
  int data1[]={1 , 3 , 5 , 7 , 9};
  int n1 = sizeof(data1)/ sizeof(data1[0]);
  int data2[]={2 , 4 , 6 , 8 , 10};
  int n2 = sizeof(data2)/ sizeof(data2[0]);
  DLinkNode* head1 = createlistF(data1,n1);
  DLinkNode* head2 = createlistR(data2,n2);
  //测试用例
  //printflist(head1); 
  //printflist(head2);
  //初始化
  DLinkNode* head = NULL;
  initlist(&head);
  head = head1;
  //判断是否为空
  emptylist(head); 
  //求长度
  int length = lengthlist(head);
  printf("线性表的长度为%d\n",length); 
  //打印线性表
  printf("表为:");
  printflist(head);
  //求第一个值为i的元素序号
  locatelist(head,9); 
  //插入第i个元素
  insertlist(&head,3,6);
  printflist(head);
  //删除第i个元素
  deletelist(&head,2);
  printflist(head);
  //删除线性表 
  destroylist(&head);
  return 0;
}

6.把单链表按基准划分：

#include<stdio.h>
#include<stdlib.h>
//创建节点 
typedef char ElemType;
typedef struct Node {
  ElemType data;
  struct Node* next;
}Node;
//将单链表以x为基准划分 
void Split(Node** head, ElemType x)
{
    Node* current = *head;
    Node* smallerHead = NULL;
    Node* smallerTail = NULL;
    Node* largerHead = NULL;
    Node* largerTail = NULL;
    while (current != NULL)
    {
        if (current->data < x)
        {
            if (smallerHead == NULL) {
                smallerHead = current;
                smallerTail = current;
            }
            else {
                smallerTail->next = current;
                smallerTail = current;
            }
        }
        else
        {
            if (largerHead == NULL) {
                largerHead = current;
                largerTail = current;
            }
            else {
                largerTail->next = current;
                largerTail = current;
            }
        }
        current = current->next;
    }
    if (smallerHead == NULL) {
        *head = largerHead;
    }
    else {
        smallerTail->next = largerHead;
        *head = smallerHead;
    }
    if (largerTail != NULL) {
        largerTail->next = NULL;
    }
}
//头插法创建一个单链表
Node* createlistf(int data[],int n)
{
  Node* head = NULL;
  int i = 0;
  for(i = 0; i < n; i++)
  {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
    newNode->data = data[i];
    newNode->next = head;
    head = newNode;
  }
  return head;
} 
void destroylist(Node **head)
{
  Node *current = *head;
  Node *next = NULL;
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
  *head = NULL;
}
void printflist(Node *head)
{
  Node *p = head;
  while (p != NULL)
  {
    printf("%d ", p->data);
    p = p->next;
  }
  printf("\n");
}
int main()
{
  int data1[] = {1 , 3 , 5 , 7 , 9};
    int n1 = sizeof(data1) / sizeof(data1[0]);
  Node* head = createlistf(data1, n1);
  printflist(head);
  ElemType x = 7;
  printf("以7为基准划分：\n");
  Split(&head,x);
  printflist(head);
  return 0;
}

7.简单合并单链表（不涉及排序）：

#include<stdio.h>
#include<stdlib.h>
//创建节点 
typedef char ElemType;
typedef struct Node {
  ElemType data;
  struct Node* next;
}Node;
//合并单链表
void merge(Node** head1, Node** head2, Node** head3)
{
  Node* p = *head1;
  Node* q = *head2;
  Node dummy; // 创建一个哑节点作为合并链表的开始
    Node* r = &dummy; // r指向哑节点
  while (q != NULL && p != NULL)
  {
    r->next = p; // 将p节点连接到r
        p = p->next; // 移动p到下一个节点
        r = r->next; // 移动r到下一个节点
        r->next = q; // 将q节点连接到r
        q = q->next; // 移动q到下一个节点
        r = r->next; // 移动r到下一个节点 
  }
  if (p != NULL)
    {
        r->next = p;
    }
    else if (q != NULL)
    {
        r->next = q;
    }
    *head3 = dummy.next; // 设置head3为合并后链表的头节点
}
//头插法创建一个单链表
Node* createlistf(int data[],int n)
{
  Node* head = NULL;
  int i = 0;
  for(i = 0; i < n; i++)
  {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
    newNode->data = data[i];
    newNode->next = head;
    head = newNode;
  }
  return head;
} 
void destroylist(Node **head)
{
  Node *current = *head;
  Node *next = NULL;
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
  *head = NULL;
}
void printflist(Node *head)
{
  Node *p = head;
  while (p != NULL)
  {
    printf("%d ", p->data);
    p = p->next;
  }
  printf("\n");
}
int main()
{
    int data1[] = {1 , 3 , 5 , 7 , 9};
    int n1 = sizeof(data1) / sizeof(data1[0]);
    int data2[] = {2 , 4 , 6 , 8 , 10};
    int n2 = sizeof(data2) / sizeof(data2[0]);
    Node* head1 = createlistf(data1, n1);
  Node* head2 = createlistf(data2, n2);
  Node* head3 = NULL;
  printf("合并为:\n");
  merge(&head1,&head2,&head3);
  printflist(head3);
  return 0;
}

​

8.合并单链表​（有序：小到大）：

#include<stdio.h>
#include<stdlib.h>
​
//创建节点 
typedef char ElemType;
​
typedef struct Node {
  ElemType data;
  struct Node* next;
}Node;
​
//合并单链表
void merge(Node** head1, Node** head2, Node** head3)
{
  Node* p = *head1;
  Node* q = *head2;
  Node dummy; // 创建一个哑节点作为合并链表的开始
    Node* r = &dummy; // r指向哑节点
  
  while (q != NULL && p != NULL)
  {
    
    if(p->data < q->data)
    {
      r->next = p;
      p = p->next;
    }
    else
        {
            r->next = q;
            q = q->next;
        }
        r = r->next;
  }
​
  if (p != NULL)
    {
        r->next = p;
    }
    else if (q != NULL)
    {
        r->next = q;
    }
​
    *head3 = dummy.next; // 设置head3为合并后链表的头节点
}
​
Node* createlistr(int data[],int n)
{
  Node *head = NULL;;
  Node *tail = NULL;;
  
  int i = 0;
  for (i = 0; i < n; i++)
  {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
    
    newNode->data = data[i];
    newNode->next = NULL;
​
        if (head == NULL)
        {
            head = newNode;
            tail = newNode;
        }
        else
        {
            tail->next = newNode;
            tail = newNode;
        }
  } 
    
  return head;
} 
​
void destroylist(Node **head)
{
  Node *current = *head;
  Node *next = NULL;
  
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
  
  *head = NULL;
}
​
void printflist(Node *head)
{
  Node *p = head;
  while (p != NULL)
  {
    printf("%d ", p->data);
    p = p->next;
  }
  printf("\n");
}
​
​
int main()
{
    int data1[] = {1 , 3 , 5 , 7 , 9};
    int n1 = sizeof(data1) / sizeof(data1[0]);
    
    int data2[] = {2 , 4 , 6 , 8 , 10};
    int n2 = sizeof(data2) / sizeof(data2[0]);
​
    Node* head1 = createlistr(data1, n1);
  Node* head2 = createlistr(data2, n2);
  Node* head3 = NULL;
  
  printf("合并为:\n");
  merge(&head1,&head2,&head3);
  printflist(head3);
  
  return 0;
}

​ 

9.用单链表实现交、并和差：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
​
#define MAX 100;
​
typedef struct
{
  double coef;  //系数
  int exp;    //指数
}PolyArray;
​
typedef struct pnode
{
  double coef;  //系数
  int exp;    //指数
  struct pnode* next;
}PolyNode;
​
//尾插法建立单链表
PolyNode* createlistR(PolyArray a[], int n)
{
  PolyNode* head = NULL;
  PolyNode* tail = NULL;
​
  int i = 0;
  for (i = 0; i < n; i++)
  {
    PolyNode* newNode = (PolyNode*)malloc(sizeof(PolyNode));
​
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
​
    newNode->coef = a[i].coef;
    newNode->exp = a[i].exp;
​
    newNode->next = NULL;
​
​
    if (head == NULL)
    {
      head = newNode;
      tail = newNode;
    }
    else
    {
      tail->next = newNode;
      tail = newNode;
    }
  }
  return head;
}
​
//打印
void DispPoly(PolyNode* head)
{
  bool first = true;
​
  PolyNode* p = head;
​
  while (p != NULL)
  {
​
    if (first)
    {
      first = false;
    }
    else if (p->coef > 0)
    {
      printf("+");
    }
​
    switch (p->exp)
    {
    case 0:
      printf("%g", p->coef);
      break;
    case 1:
      printf("%gx", p->coef);
      break;
    default:
      printf("%gx^%d", p->coef, p->exp);
      break;
    }
​
    p = p->next;
  }
​
  printf("\n");
}
​
void Sort(PolyNode** head)
{
  if (*head == NULL || (*head)->next == NULL) {
    return; // 如果链表为空或只有一个节点，无需排序
  }
​
  bool swapped;
  PolyNode** ptr;
  do {
    swapped = false;
    ptr = head;
​
    while ((*ptr)->next != NULL) {
      if ((*ptr)->exp < (*ptr)->next->exp) {
        // 交换节点
        PolyNode* temp = *ptr;
        *ptr = (*ptr)->next;
        temp->next = (*ptr)->next;
        (*ptr)->next = temp;
​
        swapped = true;
      }
      ptr = &((*ptr)->next);
    }
  } while (swapped);
}
​
//销毁线性表
void destroylist(PolyNode** head)
{
  PolyNode* current = *head;
  PolyNode* next = NULL;
​
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
​
  *head = NULL;
}
​
// 辅助函数：向结果多项式中添加项
void AddTerm(PolyNode** hc, double coef, int exp) {
    if (coef == 0) return; // 如果系数为0，直接返回，不添加
​
    PolyNode* newNode = (PolyNode*)malloc(sizeof(PolyNode));
    newNode->coef = coef;
    newNode->exp = exp;
    newNode->next = NULL;
​
    if (*hc == NULL || (*hc)->exp < exp) { // 如果链表为空或当前项指数大于链表头指数
        newNode->next = *hc;
        *hc = newNode;
    } else {
        PolyNode* prev = NULL;
        PolyNode* curr = *hc;
        while (curr != NULL && curr->exp > exp) {
            prev = curr;
            curr = curr->next;
        }
        if (curr != NULL && curr->exp == exp) { // 找到相同指数的项
            curr->coef += coef; // 合并系数
            if (curr->coef == 0) { // 如果合并后系数为0
                if (prev != NULL) {
                    prev->next = curr->next; // 从链表中删除当前项
                } else {
                    *hc = curr->next; // 更新头指针
                }
                free(curr); // 释放内存
            }
            free(newNode); // 释放新创建的节点，因为已经合并
        } else { // 没有找到相同指数的项，插入新项
            newNode->next = curr;
            if (prev != NULL) {
                prev->next = newNode;
            } else {
                *hc = newNode; // 更新头指针
            }
        }
    }
}
​
​
// 多项式乘法函数
void Mult(PolyNode* ha, PolyNode* hb, PolyNode** hc) {
    *hc = NULL; // 初始化结果多项式为空
    PolyNode* pa = ha;
    PolyNode* pb = NULL;
​
    while (pa != NULL) {
        pb = hb;
        while (pb != NULL) {
            // 计算乘积项的系数和指数
            double coef = pa->coef * pb->coef;
            int exp = pa->exp + pb->exp;
            // 将乘积项添加到结果多项式中
            AddTerm(hc, coef, exp);
            pb = pb->next;
        }
        pa = pa->next;
    }
}
​
​
int main()
{
  PolyArray a[] = { {2,1},{3,3} };
  PolyArray b[] = { {2,1},{3,3} };
​
  PolyNode* ha = createlistR(a, 2);
  PolyNode* hb = createlistR(b, 2);
​
  //打印
  printf("初始多项式:\n");
  DispPoly(ha);
  DispPoly(hb);
​
​
  Sort(&ha);
  Sort(&hb);
  printf("排序后多项式:\n");
  DispPoly(ha);
  DispPoly(hb);
​
  //多项式相乘 
  PolyNode* hc; 
  Mult(ha,hb,&hc);
  printf("多项式相乘后:\n");
  DispPoly(hc);
​
  destroylist(&ha);
  destroylist(&hb);
  destroylist(&hc);
​
  return 0;
}

​

10.实现两个多项式相加：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
​
#define MAX 100;
​
typedef struct
{
  double coef;  //系数
  int exp;    //指数
}PolyArray;
​
typedef struct pnode
{
  double coef;  //系数
  int exp;    //指数
  struct pnode* next;
}PolyNode;
​
//尾插法建立单链表
PolyNode* createlistR(PolyArray a[], int n)
{
  PolyNode* head = NULL;
  PolyNode* tail = NULL;
​
  int i = 0;
  for (i = 0; i < n; i++)
  {
    PolyNode* newNode = (PolyNode*)malloc(sizeof(PolyNode));
​
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
​
    newNode->coef = a[i].coef;
    newNode->exp = a[i].exp;
​
    newNode->next = NULL;
​
​
    if (head == NULL)
    {
      head = newNode;
      tail = newNode;
    }
    else
    {
      tail->next = newNode;
      tail = newNode;
    }
  }
  return head;
}
​
//打印
void DispPoly(PolyNode *head)
{
  bool first = true;
​
  PolyNode* p = head;
​
  while (p != NULL)
  {
​
    if (first)
    {
      first = false;
    }
    else if(p->coef > 0)
    {
      printf("+");
    }
​
    switch (p->exp)
    {
      case 0:
        printf("%g", p->coef);
        break;
      case 1:
        printf("%gx", p->coef);
        break;
      default:
        printf("%gx^%d", p->coef, p->exp);
        break;
    }
    
    p = p->next;
  }
​
  printf("\n");
}
​
void Sort(PolyNode **head)
{
    if (*head == NULL || (*head)->next == NULL) {
        return; // 如果链表为空或只有一个节点，无需排序
    }
​
    bool swapped;
    PolyNode **ptr;
    do {
        swapped = false;
        ptr = head;
​
        while ((*ptr)->next != NULL) {
            if ((*ptr)->exp < (*ptr)->next->exp) {
                // 交换节点
                PolyNode *temp = *ptr;
                *ptr = (*ptr)->next;
                temp->next = (*ptr)->next;
                (*ptr)->next = temp;
​
                swapped = true;
            }
            ptr = &((*ptr)->next);
        }
    } while (swapped);
}
​
// 向多项式中添加项
void AddTerm(PolyNode** head, double coef, int exp) {
    PolyNode* newNode = (PolyNode*)malloc(sizeof(PolyNode));
    newNode->coef = coef;
    newNode->exp = exp;
    newNode->next = NULL;
​
    if (*head == NULL) {
        *head = newNode;
    } else {
        PolyNode* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}
​
// 多项式相加函数
void AddPolynomials(PolyNode* pa, PolyNode* pb, PolyNode** pc) {
    *pc = NULL; // 初始化结果多项式为空
    while (pa != NULL && pb != NULL) {
        if (pa->exp > pb->exp) {
            AddTerm(pc, pa->coef, pa->exp);
            pa = pa->next;
        } else if (pa->exp < pb->exp) {
            AddTerm(pc, pb->coef, pb->exp);
            pb = pb->next;
        } else {
            double sumCoef = pa->coef + pb->coef;
            if (sumCoef != 0) { // 如果系数和不为0，则添加到结果多项式中
                AddTerm(pc, sumCoef, pa->exp);
            }
            pa = pa->next;
            pb = pb->next;
        }
    }
​
    // 处理剩余项
    while (pa != NULL) {
        AddTerm(pc, pa->coef, pa->exp);
        pa = pa->next;
    }
​
    while (pb != NULL) {
        AddTerm(pc, pb->coef, pb->exp);
        pb = pb->next;
    }
}
​
//销毁线性表
void destroylist(PolyNode **head)
{
  PolyNode *current = *head;
  PolyNode *next = NULL;
  
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
  
  *head = NULL;
}
​
int main()
{
  PolyArray a[] = { {1.2,0},{2.5,1},{3.2,3},{-2.5,5} };
  PolyArray b[] = { {-1.2,0},{2.5,1},{3.2,3},{2.5,5},{5.4,10} };
​
  PolyNode* ha = createlistR(a, 4);
  PolyNode* hb = createlistR(b, 5);
​
  //打印
  printf("初始多项式:\n");
  DispPoly(ha);
  DispPoly(hb); 
  
  
  Sort(&ha);
  Sort(&hb);
  printf("排序后多项式:\n");
  DispPoly(ha);
  DispPoly(hb); 
​
  //多项式相加
  PolyNode* hc; 
  AddPolynomials(ha,hb,&hc);
  printf("多项式相加后:\n");
  DispPoly(hc);
  
  destroylist(&ha);
  destroylist(&hb);
  destroylist(&hc);
  
  return 0;
}

​

​11.实现两个多项式相乘：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
​
#define MAX 100;
​
typedef struct
{
  double coef;  //系数
  int exp;    //指数
}PolyArray;
​
typedef struct pnode
{
  double coef;  //系数
  int exp;    //指数
  struct pnode* next;
}PolyNode;
​
//尾插法建立单链表
PolyNode* createlistR(PolyArray a[], int n)
{
  PolyNode* head = NULL;
  PolyNode* tail = NULL;
​
  int i = 0;
  for (i = 0; i < n; i++)
  {
    PolyNode* newNode = (PolyNode*)malloc(sizeof(PolyNode));
​
    if (newNode == NULL)
    {
      printf("位置不合法");
      return NULL;
    }
​
    newNode->coef = a[i].coef;
    newNode->exp = a[i].exp;
​
    newNode->next = NULL;
​
​
    if (head == NULL)
    {
      head = newNode;
      tail = newNode;
    }
    else
    {
      tail->next = newNode;
      tail = newNode;
    }
  }
  return head;
}
​
//打印
void DispPoly(PolyNode* head)
{
  bool first = true;
​
  PolyNode* p = head;
​
  while (p != NULL)
  {
​
    if (first)
    {
      first = false;
    }
    else if (p->coef > 0)
    {
      printf("+");
    }
​
    switch (p->exp)
    {
    case 0:
      printf("%g", p->coef);
      break;
    case 1:
      printf("%gx", p->coef);
      break;
    default:
      printf("%gx^%d", p->coef, p->exp);
      break;
    }
​
    p = p->next;
  }
​
  printf("\n");
}
​
void Sort(PolyNode** head)
{
  if (*head == NULL || (*head)->next == NULL) {
    return; // 如果链表为空或只有一个节点，无需排序
  }
​
  bool swapped;
  PolyNode** ptr;
  do {
    swapped = false;
    ptr = head;
​
    while ((*ptr)->next != NULL) {
      if ((*ptr)->exp < (*ptr)->next->exp) {
        // 交换节点
        PolyNode* temp = *ptr;
        *ptr = (*ptr)->next;
        temp->next = (*ptr)->next;
        (*ptr)->next = temp;
​
        swapped = true;
      }
      ptr = &((*ptr)->next);
    }
  } while (swapped);
}
​
//销毁线性表
void destroylist(PolyNode** head)
{
  PolyNode* current = *head;
  PolyNode* next = NULL;
​
  while (current != NULL)
  {
    next = current->next;
    free(current);
    current = next;
  }
​
  *head = NULL;
}
​
// 辅助函数：向结果多项式中添加项
void AddTerm(PolyNode** hc, double coef, int exp) {
    if (coef == 0) return; // 如果系数为0，直接返回，不添加
​
    PolyNode* newNode = (PolyNode*)malloc(sizeof(PolyNode));
    newNode->coef = coef;
    newNode->exp = exp;
    newNode->next = NULL;
​
    if (*hc == NULL || (*hc)->exp < exp) { // 如果链表为空或当前项指数大于链表头指数
        newNode->next = *hc;
        *hc = newNode;
    } else {
        PolyNode* prev = NULL;
        PolyNode* curr = *hc;
        while (curr != NULL && curr->exp > exp) {
            prev = curr;
            curr = curr->next;
        }
        if (curr != NULL && curr->exp == exp) { // 找到相同指数的项
            curr->coef += coef; // 合并系数
            if (curr->coef == 0) { // 如果合并后系数为0
                if (prev != NULL) {
                    prev->next = curr->next; // 从链表中删除当前项
                } else {
                    *hc = curr->next; // 更新头指针
                }
                free(curr); // 释放内存
            }
            free(newNode); // 释放新创建的节点，因为已经合并
        } else { // 没有找到相同指数的项，插入新项
            newNode->next = curr;
            if (prev != NULL) {
                prev->next = newNode;
            } else {
                *hc = newNode; // 更新头指针
            }
        }
    }
}
​
​
// 多项式乘法函数
void Mult(PolyNode* ha, PolyNode* hb, PolyNode** hc) {
    *hc = NULL; // 初始化结果多项式为空
    PolyNode* pa = ha;
    PolyNode* pb = NULL;
​
    while (pa != NULL) {
        pb = hb;
        while (pb != NULL) {
            // 计算乘积项的系数和指数
            double coef = pa->coef * pb->coef;
            int exp = pa->exp + pb->exp;
            // 将乘积项添加到结果多项式中
            AddTerm(hc, coef, exp);
            pb = pb->next;
        }
        pa = pa->next;
    }
}
​
​
int main()
{
  PolyArray a[] = { {2,1},{3,3} };
  PolyArray b[] = { {2,1},{3,3} };
​
  PolyNode* ha = createlistR(a, 2);
  PolyNode* hb = createlistR(b, 2);
​
  //打印
  printf("初始多项式:\n");
  DispPoly(ha);
  DispPoly(hb);
​
​
  Sort(&ha);
  Sort(&hb);
  printf("排序后多项式:\n");
  DispPoly(ha);
  DispPoly(hb);
​
  //多项式相乘 
  PolyNode* hc; 
  Mult(ha,hb,&hc);
  printf("多项式相乘后:\n");
  DispPoly(hc);
​
  destroylist(&ha);
  destroylist(&hb);
  destroylist(&hc);
​
  return 0;
}

无限大.
关注
专栏目录
数据结构-线性表
u013341672的博客
09-21 544
循环链表时另一种链式存储结构，它的特点是最后一个节点的指针指向头节点，整个链表形成一个环。循环链表可有单链的循环链表，也可以有多重链的循环链表。循环双链表不仅尾结点指向头结点，且头结点的prior指向尾结点，判断为空时，只要看尾结点下一个是否指向头结点。双向链表 双向链表中存在两个指针域，一个指向直接后继，一个指向直接前驱。是用数组来表示链表,用数组元素的下标来模拟链表的指针.来定义的链表,属于静态储存分配, 因而叫做静态链表.部分算法题目 --力扣。
数据结构--线性表初始化和插入数据
aj的博客
05-17 1271
线性表 按存储方式不同 连续存储空间分组称为顺序存储 非连续存储空间称为链表 线性表基本概念 线性结构是一种最简单且常用的数据结构，基本的特点是节点之间满足线性关系。 线性表是零个或者多个数据元素的有限序列，数据元素之间是顺序的，数据元素个数是有限的，数据元素类型必须相同。 顺序存储 动态数据 默认数组不足之处：不能实现动态增长。动态数组就为解决上述问题。 首先我们要明白数组是一块连续的内存空间。 需要我们提前了解的是： 1、我们必须知道存储数据元素的空间首地址 2、元素的个数 3、数组容量 插入数据代码
数据结构--线性表之顺序表
touchinaiyou的博客
04-24 796
数据结构--线性表之顺序表
数据结构--线性表问题总结
qq_74896248的博客
09-17 531
for循环语句中的逻辑错误，在这个逻辑中其实只循环了一次，第一次如果判断成功，不报错，而只要不是第一次能判断成功，那么都回到else语句中，直接return -1。问题：在find函数中，for循环中不可以写作int i=0；应该在for循环外部定义再在for循环赋值。而当查找为1时，即第一次if内语句未实现，而else语句实现，就会报错。一种可能，vs2010支持不是c99，无法在for中定义。
数据结构--线性表顺序存储
Seinlvan的博客
09-29 700
1 线性表定义 由零个或多个数据元素组成的有限序列。 数学定义 若将线性表记为（a1,…,ai-1,ai,ai+1,…an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素。 所以线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。 2 抽象数据类型 ADT 一个数学模型及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。 ADT 抽象数据类型名 Data 数据元素
大话数据结构--线性表
全网粉丝10W+、全栈领域优质创作者、掘金、阿里云等社区博客专家、专注于全栈领域和毕业项目实战
11-13 1071
线性表总目录前言三、线性表3.1 线性表的定义3.1.1实例3.2线性表的抽象数据类型3.3 线性表的顺序存储结构3.3.1 顺序存储定义3.3.2顺序存储方式3.3.3数据长度与线性表长度区别3.3.4 地址计算方法3.4 顺序存储结构的插入与删除3.4.1 获得元素操作3.4.2 插入操作3.4.3 删除操作3.4.4 线性表顺序存储结构的优缺点3.5 线性表的链式存储结构3.5.1 顺序存储结构不足的解决办法3.5.2线性表链式存储结构定义1.数据域和指针域2.头指针3.5.3 头指针与头结点的异同3
数据结构-线性表-思维导图+小结
学习记录
11-12 2293
数据结构-线性表-思维导图+习题小结
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构-- 线性表
06-09
线性表（linear list）是最基本、最简单、也是最常用的一种数据结构 线性表中数据元素之间的关系是一对一的关系， 即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的 特征1：集合中必存在唯一的一个...
2.C-数据结构-线性表-线性表源码
09-07
2.C-数据结构-线性表-线性表源码
数据结构--线性表.cpp
03-08
数据结构--线性表.cpp
数据结构--线性表PPT学习教案.pptx
10-05
线性表是数据结构的基础，它是一个包含n个相同类型数据元素的有限序列，通常表示为(a1, a2, a3, ..., an)。在实际应用中，线性表非常常见，比如数学中的数列、英文字母表或者电话号码簿等。线性表的特征在于每个元素...
数据结构：线性表的顺序存储
weixin_74300052的博客
09-08 636
Hello,大家好，我是小珑也要变强（也是小珑），我是易编程·终身成长社群的一名“创始团队·嘉宾”和“内容共创官”,现在我来为大家介绍一下有关物联网-嵌入式方面的内容。线性表的顺序存储结构我们也叫做顺序表，它指的是用一段地址连续的存储单元依次存储线性表中的数据元素。如下图：通过上图，结合之前的C语言学习，我们基本明白，线性表的本质就是我们对于数组的操作。
Java数据结构（八）——插入排序、希尔排序
xiaokuer_的博客
09-07 1024
文章介绍了两种插入式排序方法：插入排序和希尔排序。
【数据结构】单链表的应用
2302_81312180的博客
09-07 448
给你一个链表的头节点head和一个整数val，请你删除链表中所有满足的节点，并返回。思路： 创建新链表，找值不为val的节点，尾插到新链表中。给你单链表的头节点head，请你反转链表，并返回反转后的链表。 给你单链表的头结点head，请你找出并返回链表的中间结点。 如果有两个中间结点，则返回第二个中间结点。
数据结构-图
最新发布
ya888g
09-13 389
邻接表（Adjacency List）：使用链表或数组列表表示图，其中每个顶点都有一个与之关联的链表或数组列表，存储与其相邻的顶点。广度优先搜索（Breadth-First Search, BFS）：从某个顶点出发，逐层访问其相邻顶点，直到所有可达顶点都被访问过。最小生成树问题：在一个连通图中找到一棵包含所有顶点的树，使得树的所有边的权值之和最小，如Kruskal算法、Prim算法等。权重（Weight）：与边相关联的数值，表示边的某种属性，如距离、成本等。顶点（Vertex）：图中的节点，通常表示为V。
数据结构10
m0_52024881的博客
09-10 411
假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点(k为正整数)。若查找成功，算法输出该结点的data域的值，并返回1;（3）根据设计思想和实现步骤，采用程序设计语言描述算法(使用C、C++或Java语言实现)，关键之处请给出简要注释。这里需要注意一下递归出现的位置。（1）描述算法的基本设计思想。（2）描述算法的详细实现步骤。
数据结构(并查集) How did you do it? 怎么做到的！！!
zyh_Jan22的博客
09-10 823
并查集的历史1964年， Bernard A. Galler 和 Michael J. Fischer 首次描述了不相交的并查集，1975 年，Robert Tarjan 是第一个证明O(ma(n))（）算法时间复杂度的上限，并且在 1979 年表明这是受限情况的下限。2007 年，Sylvain Conchon 和 Jean-Christophe Filliâtre 开发并查集数据结构的半持久版本，并使用证明助手 Coq 将其正确性形式化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值