2.6作业

作业

1，实现双向链表按元素删除

2，实现循环双向链表按位置插入

3，实现约瑟夫环

4，删除链表中的所有结点

5，实现单向链表的简单选择排序

单循环链表 约瑟夫报数环，选择排序

#include"head.h"
// vsp xxx
int main(int argc, const char *argv[])
{
    loop_linklist *p=app_head();

    loop_linklist_behind_insert(p);
    loop_linklist_behind_insert(p);
    loop_linklist_behind_insert(p);
    loop_linklist_behind_insert(p);
    loop_linklist_behind_insert(p);
    loop_linklist_behind_insert(p);
    
//    josepho(p,4);

    loop_linklist_choice_arrange(p);
    loop_linklist_output(p);
}

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int datatype;
typedef struct link_list
{
    union
    {
    int len;
    datatype data;
    };
     struct link_list *next;
}loop_linklist;
loop_linklist *app_head();
loop_linklist *app_node();
void loop_linklist_behind_insert(loop_linklist *p);
void loop_linklist_output(loop_linklist *p);
void josepho(loop_linklist *p,int num1);
void loop_linklist_choice_arrange(loop_linklist *p);
#endif

#include"head.h"
loop_linklist *app_head()
{
    loop_linklist *p;
    p=malloc(sizeof(loop_linklist));
    if(p==NULL)
        printf("失败\n");
    p->len=0;
    p->next=p; 
    return p;
}
loop_linklist *app_node()
{
    loop_linklist *p1;
    p1=malloc(sizeof(loop_linklist));
    printf("输入数据\n");
    scanf("%d",&p1->data);
    p1->next=NULL;
    return p1;
}
void loop_linklist_behind_insert(loop_linklist *p)
{
    printf("尾插入\n");
    loop_linklist *p1=p;
    while(p1->next!=p)
    {
        p1=p1->next;
    }
    loop_linklist *p2=app_node();
    p2->next=p;
    p1->next=p2;
    p->len++;
}
void loop_linklist_output(loop_linklist *p)
{
    if(p->len!=0)
    {   
        printf("目前链表有\n");
        loop_linklist *p1=p->next;
    /*    for(int i=1;i<=p->len;i++)
        {
            printf("%d\n",p->data);
        }
    */

        while(p1!=p)
        {
            printf("%d\n",p1->data);
            p1=p1->next;
        }
    }
}
void josepho(loop_linklist *p,int num1)
{
    loop_linklist *p1=p,*p2;
    int i,n=p->len,count;
    for(i=1;i<=n-1;i++)
    {
        count=1;
        while(count<=num1-1)//出循环后count在num1
        {    
            p2=p1;
            if(p1==p)
            {
                count--;
            }
            p1=p1->next;
            count++;
        }
        if(p1==p)
        {
            p2=p1;
            p1=p1->next;        
        }
            p2->next=p1->next;
        printf("移除%d\n",p1->data);
        free(p1);
        p2=p2->next;
        p1=p2;
        p->len--;
        loop_linklist_output(p);
    }
}
void loop_linklist_choice_arrange(loop_linklist *p)
{
    int MAX;
    loop_linklist *p1,*p2;
    for(int i=1;i<=p->len;i++)
    {
        p1=p->next;
        MAX=0;
        for(int j=1;j<=p->len-i+1;j++)//找到最大值 
        {
            if(p1->data>MAX)
            {
                p2=p1;
                MAX=p1->data;
            }
            p1=p1->next;
        }
        while(p1->next!=p2)//p1移动到P2上一个节点
        {
            p1=p1->next;
        }
        p1->next=p2->next;
        p2->next=p;
        while(p1->next!=p)//p1移动到链表最后,实现最大值尾插
        {
            p1=p1->next;
        }
        p1->next=p2;
    }
    printf("排序后\n");
}

双向链表 按元素删除

#include"head.h"
// vsp xxx
int main(int argc, const char *argv[])
{
    double_linklist *p;

    //申请堆空间    
    p=app_head();
    
    double_linklist_head_input(p);
    double_linklist_head_input(p);
    double_linklist_head_input(p);
    double_linklist_output(p);
    double_linklist_head_delete(p);
    double_linklist_output(p);
    double_linklist_behend_input(p);
    double_linklist_key_delete(p);
    double_linklist_output(p);

}

#include"head.h"
double_linklist *app_head()
{
    double_linklist *p;
    p=malloc(sizeof(double_linklist));
    if(p==NULL)
        printf("失败\n");
    p->len=0;
    p->pre=NULL;
    p->next=NULL; 
    return p;
}
double_linklist *app_node()
{
    double_linklist *p1;
    p1=malloc(sizeof(double_linklist));
    printf("输入数据\n");
    scanf("%s",p1->data);
    p1->next=NULL;
    p1->pre=NULL;
    return p1;
}
int double_linklist_empty(double_linklist *p)
{
    if(p->len==0||p->next==NULL)
    {
        printf("链表为空\n");
        return 0;;
    }
    else return 1;    
}
void double_linklist_output(double_linklist *p)
{
    printf("目前链表有\n");
    double_linklist *p1,*p2;
    p1=p->next;
    while(p1)
    {
        printf("%s\n",p1->data);
        p2=p1;
        p1=p1->next;
    }
    printf("逆序输出\n");
    while(p2!=p)
    {
        printf("%s\n",p2->data);
        p2=p2->pre;
    }
}
void double_linklist_head_input(double_linklist *p)
{
    printf("头插\n");
    double_linklist *p1=app_node();
    if(p->next==NULL)
    {
        p->next=p1;
        p1->pre=p;
    }
    else
    {
        p1->next=p->next;             //****这里没连接好*******
        p->next=p1;
        p1->next->pre=p1;
        p1->pre=p;
    }
    p->len++;
    printf("插入后有%d个数据\n",p->len);
}
void double_linklist_head_delete(double_linklist *p)
{
    if(double_linklist_empty(p))
    {
        printf("头删\n");
        double_linklist *p1=p->next;
        p->next=p1->
next;
        p1->next->pre=p;
        free(p1);
        p1=NULL;
        p->len--;
    }
}
void double_linklist_behend_input(double_linklist *p)
{
    printf("后插入\n");
    double_linklist *p1=p;
    while(p1->next)
    {
        p1=p1->next;
    }    
        double_linklist *p2=app_node();
        p2->pre=p1;
        p1->next=p2;
        p->len++;
}
void double_linklist_key_delete(double_linklist *p)
{
    printf("输入要删除的元素\n");
    char key[20];
    scanf("%s",key);
    double_linklist *p1=p->next;
    for(int i=1;i<=p->len;i++)
    {
        if(!strcmp(p1->data,key))
        {
            printf("找到了%s，删除成功\n",p1->data);    
            p1->pre->next=p1->next;
            if(p1->next!=NULL)   //****必要的判断＊＊＊＊＊＊
            {
            p1->next->pre=p1->pre;
            }
            free(p1);
            p1=NULL;
            p->len--;
            break;

        }        
        p1=p1->next;
    }
}

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct link_list
{
    union
    {
    int len;
    char data[20];
    };
     struct link_list  *pre;
     struct link_list *next;
}double_linklist;
double_linklist *app_head();
double_linklist *app_node();

int double_linklist_empty(double_linklist *p);
void double_linklist_output(double_linklist *p);
void double_linklist_head_input(double_linklist *p);
void double_linklist_head_delete(double_linklist *p);
void double_linklist_behend_input(double_linklist *p);
void double_linklist_key_delete(double_linklist *p);


#endif

循环双向链表__按位置插入__释放空间

#include"head.h"
// vsp xxx
int main(int argc, const char *argv[])
{
    loop_double_linklist *p;

    //申请堆空间    
    p=app_head();
    
    loop_double_linklist_head_input(p);
    loop_double_linklist_head_input(p);
    loop_double_linklist_head_input(p);
    loop_double_linklist_output(p);
    
    loop_double_linklist_sub_insert(p);
    loop_double_linklist_output(p);

    loop_double_linklist_free_delete(p);
} 

#ifndef __head_h__
#define __head_h__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct link_list
{
    union
    {
    int len;
    char data[20];
    };
     struct link_list  *pre;
     struct link_list *next;
}loop_double_linklist;
loop_double_linklist *app_head();
loop_double_linklist *app_node();

int loop_double_linklist_empty(loop_double_linklist *p);
void loop_double_linklist_output(loop_double_linklist *p);
void loop_double_linklist_head_input(loop_double_linklist *p);
void loop_double_linklist_sub_insert(loop_double_linklist *p);
void loop_double_linklist_free_delete(loop_double_linklist *p);
#endif

#include"head.h"
loop_double_linklist *app_head()
{
    loop_double_linklist *p;
    p=malloc(sizeof(loop_double_linklist));
    if(p==NULL)
        printf("失败\n");
    p->len=0;
    p->pre=NULL;
    p->next=NULL; 
    return p;
}
loop_double_linklist *app_node()
{
    loop_double_linklist *p1;
    p1=malloc(sizeof(loop_double_linklist));
    printf("输入数据\n");
    scanf("%s",p1->data);
    p1->next=NULL;
    p1->pre=NULL;
    return p1;
}
int loop_double_linklist_empty(loop_double_linklist *p)
{
    if(p->len==0||p->next==NULL)
    {
        printf("链表为空\n");
        return 0;;
    }
    else return 1;    
}
void loop_double_linklist_output(loop_double_linklist *p)
{
    printf("目前链表有\n");
    loop_double_linklist *p1,*p2;
    p1=p->next;
    while(p1!=p)
    {
        printf("%s\n",p1->data);
        p2=p1;
        p1=p1->next;
    }
    printf("逆序输出\n");
    while(p2!=p)
    {
        printf("%s\n",p2->data);
        p2=p2->pre;
    }
}
void loop_double_linklist_head_input(loop_double_linklist *p)
{
    printf("头插\n");
    loop_double_linklist *p1=app_node();
    if(p->next==NULL)
    {
        p->next=p1;
        p1->next=p;
        p1->pre=p;
        p->pre=p1;
    }
    else
    {
        p1->next=p->next;             //****这里没连接好*******
        p->next=p1;
        p1->next->pre=p1;
        p1->pre=p;
    }
    p->len++;
    printf("插入后有%d个数据\n",p->len);
}
void loop_double_linklist_sub_insert(loop_double_linklist *p)
{
    printf("输入要插入的位置\n");
    int sub;
    scanf("%d",&sub);
    if(sub<=0||sub>p->len+1)
        printf("插入失败\n");
    else
    {
        int i;
        loop_double_linklist *p1=p;
        for(i=1;i<sub;i++)
        {
            p1=p1->next;
        }
        loop_double_linklist *p2=app_node();
        p2->next=p1->next;
        p1->next=p2;
        p2->next->pre=p2;
        p2->pre=p1;
    }
}

void loop_double_linklist_free_delete(loop_double_linklist *p)
{
    loop_double_linklist *p1=p,*p2;
    while(p1->next!=p)
    {
        p2=p1;
        p1=p1->next;
        free(p2);
    }
    free(p1);
    p1=NULL;
    free(p);
    p=NULL;
}