单向循环链表各种操作+约瑟夫问题，双向链表各种基本操作

最新推荐文章于 2024-07-20 11:22:21 发布

晴雪纺月

最新推荐文章于 2024-07-20 11:22:21 发布

阅读量197

点赞数 3

文章标签：链表数据结构

本文链接：https://blog.csdn.net/qq_49092859/article/details/137368158

版权

约瑟夫问题：

void joseph(Node* node,int k,int m)//约瑟夫问题，k为编号为K的人开始报数为1,数到m的人出猎，出猎后的下一位报数为1
{
    if(isEmpty(node))
    {
        printf("没人你玩个锤子\n");
        return;
    }
    if(k<1||k>node->data.len)
    {
        printf("规则错误你万个锤子\n");
        return;
    }
    int len=node->data.len;
    //printf("%d\n",len);
    Node* temp=node->next;
    while (temp->next!=node)
    {
        temp=temp->next;
    }
    Node* pre=node->next;
    temp->next=pre;
    node->next=node;
    printf("游玩游戏人的编号:\n");
    wutou(pre);//测试删除头节点后是否正确，遍历无头节点的链表
    //free(node);
    Node* flag=pre;//要删除节点的指针
    pre=NULL;
    for(int i=0;i<k-1;i++)
    {
        flag=flag->next;
        temp=temp->next;
    }//让节点移位到k的位置
    //printf("%d %d\n",flag->data.text,temp->data.text);
    Node* qqq=flag->next;//找到要删除节点的后一位节点，并存储，使删除后节点对应的flag指针指向该处，使flag能够下一次游戏
    //printf("%d \n",qqq->data.text);
    int count=1;//报数
    printf("出队的编号顺序:\n");
    while (flag->next!=flag)
    {
        count=1;//一轮开始的初始报数
        while (count<=m)//报数循环
        {
            if(count==m)//报数等于规则规定数字，删除该节点
            {
                printf("%d ",flag->data.text);//输出退出游戏人物的编号
                temp->next=qqq;
                free(flag);//推出游戏
                flag=qqq;//下一轮开始flag的状态，指向被淘汰的人的后一位开始游戏
                qqq=qqq->next;//辅助记录flag下一位
                break;
            }
            count++;//没有淘汰的人时，接连报数
            temp=temp->next;
            flag=flag->next;//换人报数，这个人报数为count
            qqq=qqq->next;
        }
    }
    printf("%d\n",flag->data.text);
    free(flag);
    
}

运行事例：以编号2开始，数到3退出队伍

单向循环链表

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "xunhuan.h"
Node* initNode()//初始化节点
{
    Node* node=(Node*)malloc(sizeof(Node));
    if(NULL==node)
    {
        printf("创建单链表失败\n");
        return NULL;
    }
    node->data.len=0;
    node->next=node;
    return node;
}
int isEmpty(Node* node)//判空
{
    if(node->data.len==0)
    {
        return 1;
    }
    else
        return 0;
}
void output(Node* node)//遍历打印
{
    Node* temp=node;
    while (temp->next!=node)
    {
        temp=temp->next;
        printf("%d ",temp->data.text);
    }
    putchar(10);
    
}
void wutou(Node* node)
{
    Node* temp=node;
    printf("%d ",temp->data.text);
    while (temp->next!=node)
    {
        temp=temp->next;
        printf("%d ",temp->data.text);
    }
    putchar(10);
}
void headInsert(Node* node,elmType data)//头插法
{
    Node* newnode=(Node*)malloc(sizeof(Node));
    newnode->data.text=data;
    newnode->next=node->next;
    node->next=newnode;
    node->data.len++;
}
void tailInsert(Node* node,elmType data)//尾巴插法
{
    Node* newNode=(Node*)malloc(sizeof(Node));
    newNode->data.text=data;
    Node* temp=node;
    while (temp->next!=node)
    {
        temp=temp->next;
    }
    newNode->next=temp->next;
    temp->next=newNode;
    node->data.len++;
}
elmType deNode(Node* node)//尾巴删除
{
    if(isEmpty(node))
    {
        printf("没有什么删除的\n");
        return -1;
    }
    Node* temp=node->next;
    Node* pre=node;
    while (temp->next!=node)
    {
        pre=temp;
        temp=temp->next;
    }
    elmType x=temp->data.text;
    //printf("%d\n",x);
    pre->next=temp->next;
    free(temp);
    node->data.len--;
    return x;
}
elmType deDtata(Node* node,elmType data)//按照数据删除节点
{
    if(isEmpty(node))
    {
        printf("梅沙可以删除的\n");
        return -1;
    }
    Node* temp=node->next;
    Node* pre=node;
    while (temp!=node)
    {
        if(temp->data.text==data)
        {
            pre->next=temp->next;
            free(temp);
            node->data.len--;
            return 1;
        }
        temp=temp->next;
        pre=pre->next;
    }
    return 0;
}
elmType deHead(Node* node)//头删除
{
    if(isEmpty(node))
    {
        printf("没有节点删除\n");
        return -1;
    }
    Node* temp=node->next;
    elmType x=temp->data.text;
    node->next=temp->next;
    free(temp);
    node->data.len--;
    return x;
}
elmType deIndex(Node* node,int index)//按位删除
{
    if(isEmpty(node)||index<1||index>node->data.len)
    {
        printf("cuowu\n");
        return -1;
    }
    Node* temp=node->next;
    Node* pre=node;
    for(int i=1;i<index;i++)
    {
        temp=temp->next;
        pre=pre->next;
    }
    int x=temp->data.text;
    pre->next=temp->next;
    free(temp);
    node->data.len--;
    return x;
}
elmType insertIndex(Node* node,elmType data,int index)//按位插入
{
    Node* pre=node;
    Node* temp=node->next;
    for(int i=1;i<index;i++)
    {
        temp=temp->next;
        pre=pre->next;
    }
    Node* newNode=(Node*)malloc(sizeof(Node));
    newNode->data.text=data;
    newNode->next=temp;
    pre->next=newNode;
    node->data.len++;

}
elmType catIndex(Node* node,int index)//按位查找
{
    if(index<0||index>node->data.len)
    {
        return -1;
    }
    int flag=1;
    Node* temp=node->next;
    while (flag!=index)
    {
        temp=temp->next;
        flag++;
    }
    printf("%d\n",temp->data.text);
    return temp->data.text;
    
}
void turn(Node* node)//反转前后
{
    if(isEmpty(node)||node->data.len==1)
    {
        return;
    }
    //Node* temp=node->next;
    int len=node->data.len;
    elmType arr[len];
    for(int i=0;i<len;i++)
    {
        arr[i]=deHead(node);
    }
    for(int i=0;i<len;i++)
    {
        headInsert(node,arr[i]);
    }
}
elmType midElem(Node* node)//寻找中间
{
    if(isEmpty(node))
    {
        printf("空心的你找个登中间\n");
        return -1;
    }
    Node* fast=node->next;
    Node* slow=node->next;
    int index=1;
    while (fast!=node&&fast->next!=node)
    {
        fast=fast->next->next;
        slow=slow->next;
        index++;
    }
    printf("中间的是第%d位，数值为%d\n",index,slow->data.text);
    return slow->data.text;
}
void Bubble_sort(int arr[], int size)
{
	int j,i,tem;
	for (i = 0; i < size-1;i ++)
	{
		int count = 0;
		for (j = 0; j < size-1 - i; j++)	
		{
			if (arr[j] > arr[j+1])//这是升序排法
			{
				tem = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tem;
				count = 1;
				
			}
		}
		if (count == 0)	
				break;	
	}
 
}
void insertSort(Node* node,elmType data)//插入排序
{
    if(isEmpty(node))
    {
        tailInsert(node,data);
        return;
    }
    int len=node->data.len;
    elmType arr[len+1];
    for(int i=0;i<len;i++)
    {
        arr[i]=deHead(node);
    }
    arr[len]=data;
    Bubble_sort(arr,len+1);
    for(int i=0;i<len+1;i++)
    {
        tailInsert(node,arr[i]);
    }
}
void sortInsert(Node* node,elmType data)//直接插入排序
{
    Node* temp=(Node*)malloc(sizeof(Node));
    temp->data.text=data;
    Node* pre=node;
    while (pre->next!=node)
    {
        if(pre->next->data.text>data)
        {
            break;
        }
        pre=pre->next;
    }
    temp->next=pre->next;
    pre->next=temp;
    node->data.len++;
    
}
void nodeTurn(Node* node)
{
    Node* p;
    Node* q;
    p=node->next;
    node->next=node;
    while (p!=node)
    {
        q=p->next;
        p->next=node->next;
        node->next=p;
        p=q;
    }
    
}
void joseph(Node* node,int k,int m)//约瑟夫问题，k为编号为K的人开始报数为1,数到m的人出猎，出猎后的下一位报数为1
{
    if(isEmpty(node))
    {
        printf("没人你玩个锤子\n");
        return;
    }
    if(k<1||k>node->data.len)
    {
        printf("规则错误你万个锤子\n");
        return;
    }
    int len=node->data.len;
    //printf("%d\n",len);
    Node* temp=node->next;
    while (temp->next!=node)
    {
        temp=temp->next;
    }
    Node* pre=node->next;
    temp->next=pre;
    node->next=node;
    printf("游玩游戏人的编号:\n");
    wutou(pre);//测试删除头节点后是否正确，遍历无头节点的链表
    //free(node);
    Node* flag=pre;//要删除节点的指针
    pre=NULL;
    for(int i=0;i<k-1;i++)
    {
        flag=flag->next;
        temp=temp->next;
    }//让节点移位到k的位置
    //printf("%d %d\n",flag->data.text,temp->data.text);
    Node* qqq=flag->next;//找到要删除节点的后一位节点，并存储，使删除后节点对应的flag指针指向该处，使flag能够下一次游戏
    //printf("%d \n",qqq->data.text);
    int count=1;//报数
    printf("出队的编号顺序:\n");
    while (flag->next!=flag)
    {
        count=1;//一轮开始的初始报数
        while (count<=m)//报数循环
        {
            if(count==m)//报数等于规则规定数字，删除该节点
            {
                printf("%d ",flag->data.text);//输出退出游戏人物的编号
                temp->next=qqq;
                free(flag);//推出游戏
                flag=qqq;//下一轮开始flag的状态，指向被淘汰的人的后一位开始游戏
                qqq=qqq->next;//辅助记录flag下一位
                break;
            }
            count++;//没有淘汰的人时，接连报数
            temp=temp->next;
            flag=flag->next;//换人报数，这个人报数为count
            qqq=qqq->next;
        }
    }
    printf("%d\n",flag->data.text);
    free(flag);
    
}

双向链表

#include <stdio.h>
#include <stdlib.h>
#include "shuangxiang.h"
Node *initNode() // 初始化
{
    Node *node = (Node *)malloc(sizeof(Node));
    node->data.len = 0;
    node->next = NULL;
    node->pre = NULL;
    return node;
}
int isEmpty(Node *node)
{
    if (node->next == NULL)
    {
        return 1;
    }
    else
        return 0;
}
void headInsert(Node *node, elmType data)
{
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data.text = data;
    newNode->next = node->next;
    if (!isEmpty(node))
    {
        node->next->pre = newNode;
    }
    newNode->pre = node;
    node->next = newNode;
    node->data.len++;
}
void tailInsert(Node *node, elmType data)
{
    Node *newnode = (Node *)malloc(sizeof(Node));
    newnode->data.text = data;
    Node *temp = node;
    while (temp->next)
    {
        temp = temp->next;
    }
    newnode->next = temp->next;
    newnode->pre = temp;
    temp->next = newnode;
    node->data.len++;
}
elmType headDelet(Node *node)
{
    if (isEmpty(node))
    {
        printf("删除失败，空链表\n");
        return -1;
    }
    Node *temp = node->next;
    if (temp->next)
    {
        temp->next->pre = node;
    }
    node->next = temp->next;
    elmType x = temp->data.text;
    free(temp);
    node->data.len--;
    return x;
}
elmType tailDelet(Node *node)
{
    if (isEmpty(node))
    {
        printf("链表为空删除失败\n");
        return -1;
    }
    Node *temp = node->next;
    while (temp->next)
    {
        temp = temp->next;
    }
    temp->pre->next = temp->next;
    elmType x = temp->data.text;
    free(temp);
    node->data.len--;
    return x;
}
void output(Node *node)
{
    Node *temp = node->next;
    while (temp)
    {
        printf("%d ", temp->data.text);
        temp = temp->next;
    }
}
void insertIndex(Node *node, int index, elmType data)
{
    if(isEmpty(node)||index<1||index>node->data.text)
    {
        printf("输入不合法\n");
        return;
    }
    Node* temp=node;
    for(int i=0;i<index;i++)
    {
        temp=temp->next;
    }
    Node* newnode=(Node*)malloc(sizeof(Node));
    newnode->data.text=data;
    newnode->pre=temp->pre;
    temp->pre->next=newnode;
    newnode->next=temp;
    temp->pre=newnode;
    node->data.len++;
}
elmType deletIndex(Node* node,int index)
{
    if(isEmpty(node)||index<1||index>node->data.len)
    {
        printf("输入不合法，删除失败\n");
        return -1;
    }
    Node* temp=node;
    for(int i=0;i<index;i++)
    {
        temp=temp->next;
    }
    if(temp->next)
    {
        temp->next->pre=temp->pre;
    }
    temp->pre->next=temp->next;
    elmType x=temp->data.text;
    free(temp);
    node->data.len--;
    return x;
}