2月21作业-CSDN博客

本文链接：https://blog.csdn.net/2201_75470803/article/details/136219437

单链表

#include <stdio.h>
#include "./fun.h"
int main(int argc, const char *argv[])
{
   datatype num;
   linkList* head=create_linkList();
   insertHead_linkList(head,100);
   insertHead_linkList(head,10);
   insertHead_linkList(head,199);
   insertHead_linkList(head,79);
   insertHead_linkList(head,23);
   show_linkList(head);
   printf("-----------------------------\n");
   /*insertTail_linkList(head,45);
   insertTail_linkList(head,67);
   insertTail_linkList(head,89);
   insertTail_linkList(head,12);
   show_linkList(head);
   printf("len=%d\n",head->text.len);
   printf("-----------------------------\n");
   num=deleteHead_linkList(head);
   printf("删除的是:%d len=%d\n",num,head->text.len);
   num=deleteHead_linkList(head);
   printf("删除的是:%d len=%d\n",num,head->text.len);
   num=deleteTail_linkList(head);
   printf("删除的是:%d len=%d\n",num,head->text.len);
   num=deleteTail_linkList(head);
   printf("删除的是:%d len=%d\n",num,head->text.len);
   show_linkList(head);
   printf("----------------------------\n");
   insertPos_linkList(head,1,234);
   show_linkList(head);
   insertPos_linkList(head,10,24);
   insertPos_linkList(head,5,23);
   show_linkList(head);
   printf("---------------------------\n");
   deleteBypos_linkList(head,3);
   show_linkList(head);
   printf("---------------------------\n");
   insertSort_linkList(head,23);
   insertSort_linkList(head,560);
   insertSort_linkList(head,43);
   insertSort_linkList(head,12);
   reserve_linkList(head);
   show_linkList(head);*/
   num=middleNode_linkList(head);
   printf("%d\n",num);

return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include "./fun.h"

//创建一个带头结点的空的单链表
linkList* create_linkList()
{
   linkList* head=(linkList*)malloc(sizeof(linkList));
   if(NULL == head)
   {
       printf("头结点申请失败,创建单链表失败\n");
       return NULL;
   }
   head->text.len=0; //初始化头结点中链表长度为0
   head->next=NULL; //初始化头结点中的指针域为NULL
   return head;
}
//判断链表是否为空
int isEmpty_linkList(linkList* head)
{
   return head->next == NULL?1:0;
}
//头插法插入数据
int insertHead_linkList(linkList* head,datatype num)
{
       //创建一个新的结点
       linkList* temp=(linkList*)malloc(sizeof(linkList));
       if(NULL == temp)
       {
           printf("结点申请失败,头插失败\n");
           return -1;
       }
       temp->text.data = num;
       temp->next = NULL;

       //头插法插入数据
       temp->next=head->next;
       head->next=temp;

head->text.len++;
return 0;
}

//遍历
void show_linkList(linkList* head)
{
   linkList* p=head;
   while(p->next!=NULL)
   {
       p=p->next;
       printf("%d ",p->text.data);
   }
   printf("\n");

}

//从尾结点插入数据
int insertTail_linkList(linkList* head,datatype num)
{
       //创建一个新的结点
       linkList* temp=(linkList*)malloc(sizeof(linkList));
       if(NULL == temp)
       {
           printf("结点申请失败,头插失败\n");
           return -1;
       }
       //初始化新的结点
       temp->next = NULL;
       temp->text.data = num;

       //尾插法插入数据
       //找到链尾表的尾结点
       linkList* p=head;
       while(p->next!=NULL)
       {
           p = p->next;
       }

       p->next=temp;
       temp->next=NULL;
       //更新头结点中记录的链表长度
       head->text.len++;
       return 0;
}

//从头结点删除
datatype deleteHead_linkList(linkList* head)
{
   if(isEmpty_linkList(head))
   {
       printf("头删失败,链表为空\n");
       return (datatype)-1;
   }
   //头删法删除
   linkList* temp= head->next;
   head->next = temp->next;
   //宁存要删除的结点中的所有有效数据,然后释放结点
   datatype num = temp->text.data;
   free(temp);
   temp=NULL;

   //更新头结点中记录的链表长度
   head->text.len--;
   return num;
}
//从尾点删除
datatype deleteTail_linkList(linkList* head)
{
   if(isEmpty_linkList(head))
   {
       printf("头删失败,链表为空\n");
       return (datatype)-1;
   }

linkList* temp= head; //让temp指向头结点

   //循环找到倒数第2个结点
   while(temp->next->next!=NULL)
   {
       temp = temp->next;//向后移动一个
   }
   //上述循环结束后,找到了倒数第2个结点
   datatype num=temp->next->text.data;
   free(temp->next);
   temp->next=NULL;

   //更新头结点中记录的链表长度
   head->text.len--;
   return num;
}

//按位置插入数据
void insertPos_linkList(linkList* head,int pos,datatype num)
{
   //判断插入的位置是否合法
   if(pos<1 || pos>head->text.len+1)
   {
       printf("pos=%d 插入位置非法,插入失败\n",pos);
       return ;
   }
   //循环查找要插入位置的前一个节点位置
   linkList* p=head;
   for(int i=0;i<pos-1;i++)
   {
       p=p->next;
   }//上述循环完毕后,p只想要插入位置的前一个节点

   //创建一个新的节点插入到链表中
   linkList* temp=(linkList*)malloc(sizeof(linkList));
   if(NULL == temp)
   {
       printf("结点申请失败,头插失败\n");
   }
   temp->text.data=num;
   temp->next=NULL;

   //插入节点
   temp->next=p->next;
   p->next=temp;

//更新头结点中记录的链表长度
head->text.len++;

return ;
}

//按照位置删除数据,位置编号从1开始
datatype deleteBypos_linkList(linkList* head,int pos)
{
       //判断链表是否为空
   if(isEmpty_linkList(head))
   {
       printf("头删失败,链表为空\n");
       return (datatype)-1;
   }

//判断和\删除的位置是否合法
   if(pos<1 || pos>head->text.len)
   {
       printf("pos=%d 插入位置非法,插入失败\n",pos);
       return(datatype)-1;
   }

   //循环查找要删除位置的前一个节点位置
   linkList* p=head;
   for(int i=0;i<pos-1;i++)
   {
       p=p->next;
   }//上述循环完毕后,p只想要删除位置的前一个节点

   //修改指向,释放要删除的节点
   linkList* temp=p->next; //宁存要删除的结点中的地址
   p->next=temp->next;

   datatype num=temp->text.data;
   free(temp);
   temp=NULL;

   //更新头结点中记录的链表长度
   head->text.len--;
   return num;
}

void insertSort_linkList(linkList* head,datatype num)
{
   //创建一个新的节点插入到链表中
   linkList* temp=(linkList*)malloc(sizeof(linkList));
   if(NULL == temp)
   {
       printf("结点申请失败,头插失败\n");
   }
   temp->text.data=num;
   temp->next=NULL;

   linkList* p=head; //遍历链表,找到比num大的结点前一个位置

   while(p->next !=NULL)
   {
       if(p->next->text.data>temp->text.data)
       {
           break;
       }
       else
       {
           p=p->next;
       }
   }
temp->next=p->next;
   p->next=temp;

//更新头结点中记录的链表长度
head->text.len++;
}

datatype middleNode_linkList(linkList* head)
{
   //判断链表是否为空
   if(isEmpty_linkList(head))
   {
       printf("头删失败,链表为空\n");
       return (datatype)-1;
   }
   linkList* fast,*low;
   fast=low=head->next;
   int flag=0;
   while(fast!=NULL&&fast->next!=NULL)
   {
       low=low->next;
       fast=fast->next->next;
       flag=1;
   }
   if(1==flag)
       return low->text.data;
   else
       return -1;

}

#ifndef __FUN_H__
#define __FUN_H__
typedef int datatype;
union msg{
   datatype data;
   int len;
};
typedef struct node{
   union msg text;
   struct node *next;
}linkList;
linkList* create_linkList();
int insertHead_linkList(linkList* head,datatype num);
void show_linkList(linkList* head);
int insertTail_linkList(linkList* head,datatype num);
datatype deleteHead_linkList(linkList* head);
datatype deleteTail_linkList(linkList* head);
void insertPos_linkList(linkList* head,int pos,datatype num);
datatype deleteBypos_linkList(linkList* head,int pos);
void insertSort_linkList(linkList* head,datatype num);
void reserve_linkList(linkList* head);
datatype middleNode_linkList(linkList* head);

#endif

单循环链表

#include <stdio.h>
#include <stdlib.h>
#include "./fun.h"
int main(int argc, const char *argv[])
{
   datatype num;
   looplinkList* head=create_looplinkList();
   insertHead_looplinkList(head,10);
   insertHead_looplinkList(head,89);
   insertHead_looplinkList(head,45);
   show_looplinkList(head);
   printf("--------------------------------\n");
   insertTail_looplinkList(head,60);
   insertTail_looplinkList(head,78);
   insertTail_looplinkList(head,60);
   show_looplinkList(head);
   printf("--------------------------------\n");
   num=deleteHead_looplinkList(head);
   printf("头结点删除的是:%d\n",num);
   show_looplinkList(head);
   printf("--------------------------------\n");
    datatype n=deleteTail_looplinkList(head);
   printf("头尾删除的是:%d\n",n);
   show_looplinkList(head);

return 0;
}

#ifndef __FUN_H__
#define __FUN_H__
typedef int datatype;
union msg{
   datatype data;
   int len;
};
typedef struct node{
   union msg text;
   struct node *next;
}looplinkList;
looplinkList* create_looplinkList();
int insertHead_looplinkList(looplinkList* head,datatype num);

void show_looplinkList(looplinkList* head);
int insertTail_looplinkList(looplinkList* head,datatype num);
datatype deleteHead_looplinkList(looplinkList* head);

datatype deleteTail_looplinkList(looplinkList* head);

#endif

#include <stdio.h>
#include <stdlib.h>
#include "./fun.h"

//创建一个带头结点的空的单链表
looplinkList* create_looplinkList()
{
   looplinkList* head=(looplinkList*)malloc(sizeof(looplinkList));
   if(NULL == head)
   {
       printf("头结点申请失败,创建单链表失败\n");
       return NULL;
   }
   head->text.len=0; //初始化头结点中链表长度为0
   head->next=head; //初始化头结点中的指针域为自己
   return head;
}
//判断链表是否为空
int isEmpty_looplinkList(looplinkList* head)
{
   return head->next == head?1:0;
}
//头插法插入数据
int insertHead_looplinkList(looplinkList* head,datatype num)
{
       //创建一个新的结点
       looplinkList* temp=(looplinkList*)malloc(sizeof(looplinkList));
       if(NULL == temp)
       {
           printf("结点申请失败,头插失败\n");
           return -1;
       }
       temp->text.data = num;
       temp->next = NULL;

       //头插法插入数据
       temp->next=head->next;
       head->next=temp;
       head->text.len++;
       return 0;
}
//尾插法插入数据
int insertTail_looplinkList(looplinkList* head,datatype num)
{
       //创建一个新的结点
       looplinkList* temp=(looplinkList*)malloc(sizeof(looplinkList));
       if(NULL == temp)
       {
           printf("结点申请失败,头插失败\n");
           return -1;
       }
       temp->text.data = num;
       temp->next = NULL;

       //尾插法插入数据
       looplinkList* p=head;
       //判断是否是尾结点
       while(p->next!=head)
       {
           p=p->next;
       }
           temp->next=head;
           p->next=temp;

head->text.len++;
return 0;
}

//遍历
void show_looplinkList(looplinkList* head)
{
   looplinkList* p=head;
   while(p->next!=head)
   {
       p=p->next;
       printf("%d ",p->text.data);
   }
   printf("\n");

}

//头结点删除
datatype deleteHead_looplinkList(looplinkList* head)
{
   if(isEmpty_looplinkList(head)==1)
   {
       printf("头删失败,链表为空\n");
       return (datatype)-1;
   }
   //头删法删除
   looplinkList* temp=head->next;
   head->next=temp->next;
   //存要删除的数据
   datatype num=temp->text.data;
   free(temp);

   //更新头结点中记录的链表长度
   head->text.len--;
   return num;
}

//尾结点删除
datatype deleteTail_looplinkList(looplinkList* head)
{
   if(isEmpty_looplinkList(head)==1)
   {
       printf("头删失败,链表为空\n");
       return (datatype)-1;
   }
   //尾删法删除
   looplinkList* temp=head;
   while(temp->next->next!=head)
   {
       temp=temp->next;
   }
   //存要删除的数据
   datatype num=temp->next->text.data;
   free(temp->next);
   temp->next=head;
   //更新头结点中记录的链表长度
   head->text.len--;
   return num;
}

双链表

#include <stdio.h>
#include <stdlib.h>
#include "./fun.h"
int main(int argc, const char *argv[])
{
   doublelinkList* head=create_doublelinkList();
   insertHead_doublelinkList(head,30);
   insertHead_doublelinkList(head,34);
   insertHead_doublelinkList(head,78);
   insertHead_doublelinkList(head,99);
   show_doublelinkList(head);
   printf("-----------------------------\n");
   insertTail_doublelinkList(head,55);
   insertTail_doublelinkList(head,27);
   insertTail_doublelinkList(head,44);
   insertTail_doublelinkList(head,9);
   show_doublelinkList(head);
   printf("-----------------------------\n");
   datatype n=deleteHead_doublelinkList(head);
   printf("头删删除的是%d\n",n);
   show_doublelinkList(head);

   printf("-----------------------------\n");
   datatype num=deleteTail_doublelinkList(head);
   printf("尾删删除的是%d\n",num);
   show_doublelinkList(head);
   printf("-----------------------------\n");
   insertByPos_doublelinkList(head,2,2);
   show_doublelinkList(head);
   insertByPos_doublelinkList(head,6,89);
   show_doublelinkList(head);
   printf("-----------------------------\n");
   datatype m=deleteByPos_doublelinkList(head,2);
   printf("删除的是%d\n",m);
   show_doublelinkList(head);
   return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include "./fun.h"
//创建一个空的双向链表
doublelinkList* create_doublelinkList()
{
   doublelinkList* head=(doublelinkList*)malloc(sizeof(doublelinkList));
   if(NULL == head)
   {
       printf("创建双向链表失败\n");
       return NULL;
   }
   head->text.len=0;
   head->next=NULL;
   head->prev=NULL;

   return head;
}
int isEmpty_doublelinkList(doublelinkList* head)
{
   return head->next == NULL?1:0;
}
//头插法插入数据
void insertHead_doublelinkList(doublelinkList* head,datatype num)
{
       //创建一个新的结点
       doublelinkList* temp=(doublelinkList*)malloc(sizeof(doublelinkList));
       if(NULL == temp)
       {
           printf("结点申请失败,头插失败\n");
       }
       temp->text.data = num;
       temp->next = NULL;
       temp->prev = NULL;

       //链表为空和链表中有数据的时候,头插的逻辑不一致
       if(isEmpty_doublelinkList(head)==1)
       {
           temp->next=head->next;
           head->next=temp;

           temp->prev=head;
       }
       else
       {
           temp->next=head->next;
           head->next=temp;
           temp->next->prev=temp;
           temp->prev=head;
       }
       //更新头结点中记录的链表长度
       head->text.len++;
       return;
}
//尾插
void insertTail_doublelinkList(doublelinkList* head,datatype num)
{
   doublelinkList* temp=(doublelinkList*)malloc(sizeof(doublelinkList));
   if(NULL == temp)
   {
       printf("创建结点失败,按位置插入失败\n");
       return;
   }

   temp->text.data = num;
   temp->next = NULL;
   temp->prev = NULL;

   doublelinkList* p=head;
   while(p->next!=NULL)
       p=p->next;
   //上述循环结束后,p存储的是最后一个节点的地址

   temp->next=p->next;
   p->next=temp;
   temp->prev=p;
   return;

}

//遍历
void show_doublelinkList(doublelinkList* head)
{
   doublelinkList* p=head;
   while(p->next!=NULL)
   {
       p=p->next;
       printf("%d ",p->text.data);
   }
   printf("\n");

}

//按位置插入
void insertByPos_doublelinkList(doublelinkList* head,datatype num,int pos)
{
   doublelinkList* temp=(doublelinkList*)malloc(sizeof(doublelinkList));
   if(NULL == temp)
   {
       printf("创建结点失败,按位置插入失败\n");
       return;
   }
   temp->text.data=num;
   temp->next=NULL;
   temp->prev=NULL;
   //判断插入位置是否合法
   if(pos<1 || pos>head->text.len+1)
   {
       printf("pos=%d 插入位置非法,插入失败\n",pos);
       return;
   }

   //找到要插入位置的前一个节点位置
   doublelinkList* p=head;
   for(int i=0;i<pos-1;i++)
   {
       p=p->next;
   }

   if(p->next!=NULL)
   {
       temp->next=p->next;
       p->next=temp;

       temp->next->prev=temp;
       temp->prev=p;
   }
   else
   {
       temp->next=p->next;
       p->next=temp;

       temp->prev=p;
   }
   head->text.len++;
   return;
}

//尾删
datatype deleteTail_doublelinkList(doublelinkList* head)
{
   doublelinkList* p=head;
   while(p->next!=NULL)
   {
       p=p->next;
   }
   datatype num=p->text.data;
   p->prev->next=NULL;
   free(p);
   return num;
}

//头删
datatype deleteHead_doublelinkList(doublelinkList* head)
{
   datatype num;
   if(isEmpty_doublelinkList(head)==1)
   {
       printf("无法删除\n");
   }
   doublelinkList* p=head->next;
   if(p->next!=NULL)
   {
       num=p->text.data;
       head->next=p->next;
       p->next->prev=head;
       free(p);
   }
   else
   {
       num=p->text.data;
       head->next=NULL;
       free(p);
   }
   return num;
}

//按位置删除
datatype deleteByPos_doublelinkList(doublelinkList* head,datatype pos)
{
   datatype num;
   doublelinkList* p=head;
   for(int i=0;i<pos;i++)
   {
       p=p->next;
   }
   if(p->next!=NULL)
   {
       num=p->text.data;
       p->prev->next=p->next;
       p->next->prev=p->prev;
       free(p);
   }
   else
   {
       num=p->text.data;
       p->prev->next=p->next;
       free(p);
   }
    return num;
}

#ifndef __FUN_H__
#define __FUN_H__
typedef int datatype;
union msg{
   datatype data;
   int len;
};
typedef struct node{
   union msg text;
   struct node* next;
   struct node* prev;
}doublelinkList;
doublelinkList* create_doublelinkList();
void insertHead_doublelinkList(doublelinkList* head,datatype num);
void show_doublelinkList(doublelinkList* head);
void insertByPos_doublelinkList(doublelinkList* head,datatype num,int pos);
void insertTail_doublelinkList(doublelinkList* head,datatype num);

datatype deleteHead_doublelinkList(doublelinkList* head);
datatype deleteTail_doublelinkList(doublelinkList* head);
datatype deleteByPos_doublelinkList(doublelinkList* head,datatype pos);

#endif