0206_数据结构作业

单向链表

--head.h--
#ifndef __HEAD_H__
#define __HEAD_H__
#include 
#include 
typedef char datatype;
typedef struct node
{
    union{
        int len;//头结点的数据域：链表长度
        datatype data;
    };
    struct node *next;
}*Linklist,node;
Linklist LinklistCreat();
Linklist LinklistCreatNode();
void InsertHead(Linklist L,datatype e);
void LinklistShow(Linklist L);
void InsertRear(Linklist L,datatype e);
void DeleteHead(Linklist L);
void DeleteRear(Linklist L);
void InsertByPos(Linklist L,int pos,datatype e);
void DeleteByPos(Linklist L,int pos);
void ChangeByPos(Linklist L,int pos,datatype e);
void SearchByPos(Linklist L,int pos);
void ChangeByEle(Linklist L,datatype e,datatype e1);
void SearchByData(Linklist L,datatype key);
int DeleteByData(Linklist L,datatype e);
void LinklistRev(Linklist L);
void LinklistSort(Linklist L);
void LinklistFree(Linklist L);
void SimpleSort(Linklist L);
#endif

--fun.c--
#include "head.h"
//在堆区申请空间
Linklist LinklistCreat()
{
    Linklist L=(Linklist)malloc(sizeof(node));
    if(L==NULL)
        return NULL;
    L->len=0;
    L->next=NULL;
    return L;
}
//创建普通节点
Linklist LinklistCreatNode()
{
    Linklist p=(Linklist)malloc(sizeof(node));
    if(p==NULL)
        return NULL;
    p->data=0;//创建新节点的数据域清0
    p->next=NULL;
    return p;
}
//头插:在头结点后插入
void InsertHead(Linklist L,datatype e)
{
    //创建新节点
    Linklist p=LinklistCreatNode();
    if(p==NULL)
        return;
    //节点创建成功
    p->data=e;
    p->next=L->next;
    L->next=p;
    L->len++;
}
//遍历链表
void LinklistShow(Linklist L)
{
#if 0
    Linklist p=L;
    for(int i=0;ilen;i++)
    {
        p=p->next;
        printf("%d\t",p->data);
    }
#endif
    printf("链表数据为：");
    while(L->next)
    {
        L=L->next;
        printf("%c\t",L->data);
    }
    printf("\n");
}
//尾插；
void InsertRear(Linklist L,datatype e)
{
    //先创建一个新节点
    Linklist p=LinklistCreatNode();
    if(p==NULL)
        return;
    //找到最后一个节点
    Linklist q=L;
    while(q->next)
    {
        q=q->next;

    }
    //把新节点放在最后一个节点的后面
    p->data=e;
    q->next=p;
    L->len++;
}
//头删:永远删除头结点的后继节点
void DeleteHead(Linklist L)
{
    if(L->next==NULL)//或L->len==0
        return;
    Linklist p=L->next;
    L->next=p->next;
    free(p);
    p=NULL;
    L->len--;
}
//尾删：永远只删除最后一个节点
void DeleteRear(Linklist L)
{
    if(L->next==NULL)
        return;
    Linklist p=L;
    //找到最后一个节点的前驱节点
    for(int i=0;ilen-1;i++)
    {
        p=p->next;
    }
    //直接释放p的后继节点/最后一个节点
    free(p->next);
    L->len--;
    p->next=NULL;
}
//链表按位置插入
//失败返回-1，成功返回0
void InsertByPos(Linklist L,int pos,datatype e)
{
    //判断链表是否为空
    //判断位置是否合法
    if(L->next==NULL || pos<1 || pos>L->len+1)
        return;
    Linklist p=L;
    for(int i=0;inext;
    }
    //p和p->next之间定义新节点
    Linklist s=LinklistCreatNode();
    s->data=e;
    s->next=p->next;
    p->next=s;
    L->len++;
}
//链表按位置删除
void DeleteByPos(Linklist L,int pos)
{
    if(L->next==NULL || pos<1 || pos>L->len)
        return;
    Linklist p=L;
    for(int i=0;inext;
    }
    Linklist s=p->next;
    p->next=s->next;
    L->len--;
    free(s);
    s=NULL;
}
//链表按位置修改
void ChangeByPos(Linklist L,int pos,datatype e)
{
    if(L->next==NULL || pos<1 ||pos>L->len)
        return;
    Linklist p=L;
    for(int i=0;inext;
    }
    p->data=e;
}
//链表按位置查找
void SearchByPos(Linklist L,int pos)
{
    if(L->next==NULL ||pos<1 ||pos>L->len)
        return;
    Linklist p=L;
    for(int i=0;inext;
    }
    printf("第%d个节点的值为%c\n",pos,p->data);
}
//链表按元素修改
void ChangeByEle(Linklist L,datatype e,datatype e1)
{
    if(L->next==NULL)
        return;
    Linklist p=L;
    int count=0;
    for(int i=0;ilen;i++)
    {
        p=p->next;
        if(p->data==e)
        {
            p->data=e1;
            count++;
            break;
        }
    }
    if(count==0)
        printf("查找元素不存在，修改失败\n");
}
//链表按元素删除
int DeleteByData(Linklist L,datatype e)
{
    if(L->next==NULL)
        return -1;
    Linklist p=L;
    for(int i=0;ilen;i++)
    {
        p=p->next;
        if(p->data==e)
        {
            DeleteByPos(L,i+1);
            return 0;
        }
    }
}
//链表按元素查找
void SearchByData(Linklist L,datatype key)
{
    if(L->next==NULL)
        return;
    Linklist p=L;
    for(int i=0;ilen;i++)
    {
        p=p->next;
        if(p->data==key)
        {
            printf("查找成功，在第%d个节点出现\n",i+1);
        }
    }
}
//链表逆置
void LinklistRev(Linklist L)
{
    if(L->len<2)
        return;
    Linklist p=L->next;//使用p节点保存第一个节点
    L->next=NULL;//把头结点孤立
    while(p)
    {
        Linklist t=p;
        p=p->next;
        t->next=L->next;
        L->next=t;
    }
}
//链表排序
void LinklistSort(Linklist l){
#if 0
    Linklist p = l->next;
    Linklist t = p;
    l->next = NULL;
    l->len=0;
    while(p){
        p = p->next;
        if(l->next==NULL){
            InsertHead(l,t->data);
            free(t);
        }
        else
        {
            Linklist s = l;
            while(t->data>s->next->data&&s->next!=NULL){
                s=s->next;
            }
            t->next = s->next;
            s->next = t;
            l->len++;
        }
        t = p;
    }
}
#endif
#if 1
    Linklist p = l->next;
    l->next = NULL;
    while(p){
        Linklist t = p;
        p = p->next;
        if(l->next==NULL){
            t->next = l->next;
            l->next = t;
        }
        else{
            Linklist q = l;
            while(q->next!=NULL&&q->next->datadata){
                q=q->next;
            }
            t->next = q->next;
            q->next = t;
        }
    }

}
#endif
//链表空间释放
void LinklistFree(Linklist L)
{
    if(L==NULL)
        return;
    for(int i=0;ilen;i++)
    {
        DeleteHead(L);
    }
    free(L);
    L=NULL;
}
//简单选择排序
void SimpleSort(Linklist L)
{
    char t;
    int pos;
    Linklist p=L;
    for(int i=0;ilen-1;i++)
    {
        p=p->next;
        pos=i;
        Linklist q=p;
        for(int j=i+1;jlen;j++)
        {
            q=q->next;
            if(p->data>q->data)
            {
                pos=j;
            }
        }
        if(pos!=i)
        {
            Linklist s=p;
            for(int k=0;knext;
            }
            t=p->data;p->data=s->data;s->data=t;
        }
    }
}
void SimpleSort(Linklist L)
{
    Linklist p,min,q;
    for(p=L->next;p!=NULL;p=p->next)
    {
        min=p;
        for(q=p->next;q!=NULL;q=q->next)
        {
            if(min->datadata)//if(a[min]data;
            min->data=p->data;
            p->data=t;
        }
    }
}
--main.c--
#include "head.h"
int main(int argc, const char *argv[])
{
    Linklist L=LinklistCreat();
    if(L==NULL)
        return -1;
#if 0
    //头插：永远在头结点的后面插入
    int n=5;
    datatype e;
    for(int i=0;i

单向循环链表

--head.h--
#ifndef __HEAD_H__
#define __HEAD_H__
#include 
#include 
#include 
typedef int datatype;
typedef struct node
{
    union
    {
        int len;
        datatype data;
    };
    struct node *next;
}*LoopLink,Node;
LoopLink CreateHead();
LoopLink CreateNode();
void InsertHead(LoopLink L,datatype e);
void LoopLinkShow(LoopLink L);
void InsertRear(LoopLink L,datatype e);
void DeleteHead(LoopLink L);
void DeleteRear(LoopLink L);
void Josepho1(LoopLink L,int m,int n);
void Josepho2(LoopLink L,int m);
#endif

--fun.c--
#include "head.h"
//单向循环链表的头结点创建
//成功返回头结点，失败返回NULL
LoopLink CreateHead()
{
    LoopLink L=(LoopLink)malloc(sizeof(LoopLink));
    if(L==NULL)
        return NULL;
    L->len=0;
    L->next=L;
    return L;
}
//单向循环链表普通节点创建
LoopLink CreateNode()
{
    LoopLink p=(LoopLink)malloc(sizeof(LoopLink));
    if(p==NULL)
        return NULL;
    p->data=0;
    p->next=NULL;
    return p;
}
//单向循环链表头插
void InsertHead(LoopLink L,datatype e)
{
    if(L==NULL)
        return;
    LoopLink p=CreateNode();
    if(p==NULL)
        return;
    p->data=e;
    p->next=L->next;
    L->next=p;
    L->len++;
}
//单向循环链表输出
void LoopLinkShow(LoopLink L)
{
    LoopLink p=L->next;
    while(p!=L)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");

}
//单向循环链表尾插
void InsertRear(LoopLink L,datatype e)
{
    if(L==NULL)
        return;
    LoopLink p=L->next;
    while(p->next!=L)
        p=p->next;
    LoopLink q=CreateNode();
    if(p==NULL)
        return;
    q->data=e;
    q->next=p->next;
    p->next=q;
    L->len++;
}
//单向循环链表头删
void DeleteHead(LoopLink L)
{
    if(L->len==0)
        return;
    LoopLink p=L->next;
    L->next=p->next;
    free(p);
    p=NULL;
    L->len--;
}
//单向循环链表尾删
void DeleteRear(LoopLink L)
{
    if(L->len==0)
        return;
    LoopLink p=L;
    for(int i=0;ilen-1;i++)
    {
        p=p->next;
    }
    LoopLink q=p->next;
    p->next=q->next;
    free(q);
    q=NULL;
    L->len--;
}
//约瑟夫环
#if 0
void Josepho1(LoopLink L,int m,int n)
{
    LoopLink p=L;
    for(int j=0;jnext;
            if(p==L)
                i--;
        }
        LoopLink q=p->next;
        if(q==L)
            q=q->next;
        printf("%d出圈\n",q->data);
        p->next=q->next;
        free(q);
        q=NULL;
    }
}
#endif
void Josepho2(LoopLink L,int m)
{
    LoopLink p=L;
    while(L->len!=0)
    {
        for(int i=0;inext;
            if(p==L)
                i--;
        }
        LoopLink q=p->next;
        if(q==L)
            q=q->next;
        printf("%d出圈\n",q->data);
        p->next=q->next;
        free(q);
        q=NULL;
        L->len--;
    }
}

--main.c--
#include "head.h"
int main(int argc, const char *argv[])
{
    LoopLink L=CreateHead();
    if(L==NULL)
    {
        printf("创建失败\n");
        return -1;
    }
    int n=8;

    //头插
#if 0
    for(int i=0;i

双向链表

--head.h--
#ifndef __HEAD_H__
#define __HEAD_H__
#include 
#include 
#include 
typedef char datatype[20];
typedef struct node
{
    union
    {
        int len;
        datatype data;
    };
    struct node *next;
    struct node *prev;
}*DoubleLink,Node;
DoubleLink CreateHead();
DoubleLink CreateNode();
void InsertHead(DoubleLink L,datatype e);
void DoubleLinkShow(DoubleLink L);
void InsertRear(DoubleLink L,datatype e);
void DeleteHead(DoubleLink L);
void DeleteByPos(DoubleLink L,int pos);
void DeleteRear(DoubleLink L);
void InsertByPos(DoubleLink L,int pos,datatype e);
void DeleteByPos(DoubleLink L,int pos);
void DeleteByData(DoubleLink L,datatype e);
void DeleteAll(DoubleLink L);
#endif

--fun.c--
#include "head.h"
//节点定义
DoubleLink CreateHead()
{
    DoubleLink L=(DoubleLink)malloc(sizeof(Node));
    if(L==NULL)
        return NULL;
    L->prev=NULL;
    L->next=NULL;
    L->len=0;
    return L;
}
DoubleLink CreateNode()
{
    DoubleLink p=(DoubleLink)malloc(sizeof(Node));
    if(p==NULL)
        return NULL;
    p->prev=NULL;
    p->next=NULL;
    strcpy(p->data,"");
    return p;
}
//头插
void InsertHead(DoubleLink L,datatype e)
{
    if(L==NULL)
        return;
    DoubleLink p=CreateNode();
    if(p==NULL)
        return;
    strcpy(p->data,e);
    p->next=L->next;
    p->prev=L;
    if(L->next!=NULL)
        L->next->prev=p;
    L->next=p;
    L->len++;
}

//尾插
void InsertRear(DoubleLink L,datatype e)
{
    if(L==NULL)
        return;
    DoubleLink p=CreateNode();
    if(p==NULL)
        return;
    strcpy(p->data,e);
    DoubleLink q=L;
    while(q->next)
    {
        q=q->next;
    }
    q->next=p;
    p->prev=q;
    L->len++;
}
//双向链表遍历
void DoubleLinkShow(DoubleLink L)
{
    if(L->len==0)
    {
        printf("链表为空，无法打印\n");
        return;
    }
    DoubleLink p=L;
    //正向打印
    printf("正向打印\n");
    while(p->next)
    {
        p=p->next;
        printf("%s\t",p->data);
    }
    //逆向打印
    printf("\n逆向打印\n");
    while(p!=L)
    {
        printf("%s\t",p->data);
        p=p->prev;
    }
    printf("\n");
}
//头删
void DeleteHead(DoubleLink L)
{
    if(L==NULL||L->len==0)
        return;
    DoubleLink p=L->next;
    L->next=p->next;
    if(p->next!=NULL)
        p->next->prev=L;
    free(p);
    p=NULL;
    L->len--;
}
//尾删
void DeleteRear(DoubleLink L)
{
    if(L==NULL||L->len==0)
        return;
    DoubleLink p=L;
    while(p->next)
    {
        p=p->next;
    }
    p->prev->next=NULL;
    free(p);
    p=NULL;
    L->len--;
}
//按位置插入
void InsertByPos(DoubleLink L,int pos,datatype e)
{
    if(L==NULL||pos<1||pos>L->len+1)
        return;
    DoubleLink p=L;
    for(int i=0;inext;
    }
    DoubleLink q=CreateNode();
    if(q==NULL)
        return;
    strcpy(q->data,e);
    q->next=p->next;
    q->prev=p;
    if(p->next!=NULL)
        p->next->prev=q;
    p->next=q;
    L->len++;
}
//按位置删除
void DeleteByPos(DoubleLink L,int pos)
{
    if(L->len==0)
    return;
    DoubleLink p=L;
    for(int i=0;inext;
    }
    p->prev->next=p->next;
    if(p->next!=NULL)
        p->next->prev=p->prev;
    L->len--;
    free(p);
    p=NULL;
}
//双向链表按元素删除
void DeleteByData(DoubleLink L,datatype e)
{
    if(L==NULL||L->len==0)
        return;
    DoubleLink p=L;
    int count=0;
    for(int i=0;ilen;i++)
    {
        p=p->next;
        if(strcmp(p->data,e)==0)
        {
            p->prev->next=p->next;
            if(p->next!=NULL)
                p->next->prev=p->prev;
            L->len--;
            free(p);
            p=NULL;
            count++;
            return;
        }
    }
    if(count==0)
        printf("未查找到该元素，删除失败\n");
}
//删除链表所有节点
void DeleteAll(DoubleLink L)
{
    if(L->len==0)
        return;
    while(L->len)
    {
        DeleteHead(L);
    }
}

--main.c--
#include "head.h"
int main(int argc, const char *argv[])
{
    DoubleLink L=CreateHead();
    if(L==NULL)
    {
        printf("头节点创建失败");
        return -1;
    }
    int n;
    printf("请输入元素个数：");
    scanf("%d",&n);

    //头插
#if 0
    datatype e;
    for(int i=0;i<5;i++)
    {
        scanf("%s",e);
        InsertHead(L,e);
    }
    DoubleLinkShow(L);
#endif

    //尾插
#if 1
    datatype e;
    for(int i=0;i

双向循环链表

--head.h--
#ifndef __HEAD_H__
#define __HEAD_H__
#include 
#include 
#include 
typedef int datatype;
typedef struct node
{
    union
    {
        datatype data;
        int len;
    };
    struct node *next;
    struct node *prev;
}*LoopDoubleLink,Node;
LoopDoubleLink CreateHead();
LoopDoubleLink CreateNode();
void InsertHead(LoopDoubleLink L,datatype e);
void Output(LoopDoubleLink L);
void InsertRear(LoopDoubleLink L,datatype e);
void DeleteHead(LoopDoubleLink L);
void DeleteRear(LoopDoubleLink L);
void InsertByPos(LoopDoubleLink L,int pos,datatype e);
void DeleteAll(LoopDoubleLink L);
void Joesph(LoopDoubleLink L);
#endif

--fun.c--
#include "head.h"
//创建双向循环链表头结点
LoopDoubleLink CreateHead()
{
    LoopDoubleLink L=(LoopDoubleLink)malloc(sizeof(Node));
    if(L==NULL)
        return NULL;
    L->len=0;
    L->next=L;
    L->prev=L;
    return L;
}
//创建双向循环链表普通节点
LoopDoubleLink CreateNode()
{
    LoopDoubleLink p=(LoopDoubleLink)malloc(sizeof(Node));
    if(p==NULL)
        return NULL;
    p->data=0;
    p->next=NULL;
    p->prev=NULL;
    return p;
}
//双向循环链表头插
void InsertHead(LoopDoubleLink L,datatype e)
{
    if(L==NULL)
        return;
    LoopDoubleLink p=CreateNode();
    if(p==NULL)
        return;
    p->data=e;
    p->next=L->next;
    p->prev=L;
    L->next->prev=p;
    L->next=p;
    L->len++;
}
//双向循环链表尾插
void InsertRear(LoopDoubleLink L,datatype e)
{
    if(L==NULL)
        return;
    LoopDoubleLink p=CreateNode();
    if(p==NULL)
        return;
    p->data=e;
    LoopDoubleLink q=L->prev;
    p->next=q->next;
    p->prev=q;
    q->next->prev=p;
    q->next=p;
    L->len++;
}
//双向循环链表遍历
void Output(LoopDoubleLink L)
{
    if(L==NULL||L->len==0)
        return;
    LoopDoubleLink p=L;
    printf("正向打印：\n");
    while(p->next!=L)
    {
        p=p->next;
        printf("%d ",p->data);
    }
    printf("\n反向打印\n");
    while(p!=L)
    {
        printf("%d ",p->data);
        p=p->prev;
    }
    printf("\n");
}
//双向循环链表头删
void DeleteHead(LoopDoubleLink L)
{
    if(L==NULL||L->len==0)
        return;
    LoopDoubleLink p=L->next;
    L->next=p->next;
    p->next->prev=L;
    L->len--;
    free(p);
    p=NULL;
}
//双向循环链表尾删
void DeleteRear(LoopDoubleLink L)
{
    if(L==NULL||L->len==0)
        return;
    LoopDoubleLink p=L->prev;
    LoopDoubleLink q=p->prev;
    q->next=L;
    L->prev=q;
    L->len--;
    free(p);
    p=NULL;
}
//双向循环链表按位置插入
void InsertByPos(LoopDoubleLink L,int pos,datatype e)
{
    if(pos<1||pos>L->len+1)
        return;
    LoopDoubleLink p=CreateNode();
    if(p==NULL)
        return;
    p->data=e;
    LoopDoubleLink q=L;
    for(int i=0;inext;
    }
    p->next=q;
    p->prev=q->prev;
    q->prev->next=p;
    q->prev=p;
    L->len++;
}
//约瑟夫环
void Joesph(LoopDoubleLink L)
{
    if(L==NULL||L->len==0)
        return;
    LoopDoubleLink p=L;
    while(L->len!=0)
    {
        for(int i=0;i<4-1;i++)
        {
            p=p->next;
            if(p==L)
                i--;
        }
        LoopDoubleLink q=p->next;
        if(q==L)
            q=q->next;
        printf("%d",q->data);
        p->next=q->next;
        q->next->prev=p;
        free(q);
        q=NULL;
        L->len--;
    }
}
//删除链表所有节点
void DeleteAll(LoopDoubleLink L)
{
    if(L->len==0)
        return;
    while(L->len)
    {
        DeleteHead(L);
    }
}

--main.c--
#include "head.h"
int main(int argc, const char *argv[])
{
    LoopDoubleLink L=CreateHead();
    if(L==NULL)
        return -1;
    //头插
#if 0
    for(int i=0;i<5;i++)
    {
        datatype e;
        printf("请输入插入的第%d个数据：",i+1);
        scanf("%d",&e);
        InsertHead(L,e);
    }
    Output(L);
#endif

    //尾插
    for(int i=0;i<7;i++)
    {
        datatype e;
        printf("请输入插入的第%d个数据：",i+1);
        scanf("%d",&e);
        InsertRear(L,e);
    }
    Output(L);

    //头删
#if 0
    DeleteHead(L);
    printf("头删后：");
    Output(L);
#endif

    //尾删
#if 0
    DeleteRear(L);
    printf("尾删后：");
    Output(L);
#endif

    //按位置插入
    int pos;
    datatype e;
    printf("请输入插入的位置：");
    scanf("%d",&pos);
    printf("请输入插入的值：");
    scanf("%d",&e);
    InsertByPos(L,pos,e);
    Output(L);
    //约瑟夫环
    Joesph(L);
    Output(L);
    
    //删除链表所有节点
    DeleteAll(L);
    free(L);
    L=NULL;    
    return 0;
}