【双向链表+链表反转+链表+KMP+约瑟夫环】

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量148 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44548244/article/details/135273468
版权

约瑟夫环

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
	int item;
	struct node  *next;
	
}node_t;

node_t *head = NULL;

node_t *mk_node(int item)
{
	node_t *p = (node_t*)malloc(sizeof(node_t));
	if (p == NULL)
	{
		printf("malloc default!");
		exit(1);		
	}
	
	p->item = item;
	p->next = NULL;
	return p;
}

void traverse()
{
	node_t *p = head;
	if(head == NULL)
	{
		return ;
	}
	while(p->next != head)
	{	
		printf("%d",p->item);
		p = p->next;
	}
	printf("%d\n",p->item);
}

node_t *init_josph(int n)
{
	int i = 0;
	node_t *tail;
	node_t *p = mk_node(1);
	
	head = p;
	head->next = head;
	tail = head; 
	
	for(i = 1; i < n; i++)
	{
		p = mk_node(i + 1);
		p->next = tail->next;
		tail->next = p;
		tail = p;
	}
	traverse();
	return head;
 } 
 
 void free_node(node_t *p)
{
	free(p);
}

int josph(int n)
{
	int total = 1;
	node_t *p = init_josph(n);
	node_t *node_next;
	while(p->next != p)
	{
		total++;
		if(total == 3)
		{
			node_next = p-> next;
			p ->next = node_next->next;
			
			printf("%d\n",node_next->item);
			free_node(node_next);
		//	traverse();
			p = p->next ;
			total = 1 ;
			continue;
		}
		p = p -> next;
	}
		printf("\n");
	int survival = p->item;
	free_node(p);
	return survival;
}

int main()
{
	printf("survival is %d\n" , josph(6));
	return 0;
}

KMP

void get_next(const char *t, int *next, int len)
2 {
3 int j = 0;
4 int k = ‐1;
5
6 next[j] = ‐1;
7
8 while (t[j] != '\0')
9 {
10 if (k == ‐1 || t[j] == t[k])
11 {
12 ++j;
13 ++k;
14 if (t[j] == t[k])
15 {
16 next[j] = next[k];
17 }else
18 {
19 next[j] = k;
20 }
21 }else
22 {
23 k = next[k];
24 }
25 }
26 }

1 int str_index_kmp(const char *s, const char *t, int pos)
2 {
3
4 int i = pos;
5 int j = 0;
6 int len = strlen(t);
7 int *next = (int *)malloc(sizeof(int) * (len + 1));
8 if (next == NULL)
9 {
10 printf("malloc failed\n");
11 exit(1);
12 }
13
14 get_next(t, next, len);
15
16 while (s[i] != '\0' && t[j]!= '\0')
17 {
18 if (s[i] == t[j])
19 {
20 i++;
21 j++;
22 }else if (j == 0)
23 {
24 i++;
25 }else
26 {
27 j = next[j];
28 printf("%d\n", i);
29 }
30 }
31
32 free(next);
33
34 if (t[j] == '\0')
35 {36 return i ‐ j;
37 }else
38 {
39 return ‐1;
40 }
41
42 }

链表

#include <stdlib.h>
#include <stdio.h>

typedef struct node 
{
	int item;
	struct node *next;
}node;

node sentinel = {0, NULL};
node *head = &sentinel;

node *mk_node(int item)
{
	node *p = (node *)malloc(sizeof(node));
	if (p == NULL)
	{
		printf("malloc failed\n");
		exit(1);
	}

	p->item = item;
	p->next = NULL;

	return p;
}

void free_node(node *p)
{
	free(p);
}

void insert_node(node *p)
{
	p->next = head->next;
	head->next = p;
}

void insert_node_l2b(node *p)
{
	node *pre = head;

	while (pre->next != NULL)
	{
		if (p->item  <= pre->next->item)
		{
			break;
		}
		pre = pre->next;
	}

	p->next = pre->next;
	pre->next = p;
}

void traverse()
{
	node *p = head->next;

	while (p != NULL)
	{
		printf("%d ", p->item);
		p = p->next;
	}
	printf("\n");
}

node *search(int target)
{
	node *p = head->next;

	while (p != NULL)
	{
		if (target == p->item)
		{
			return p;
		}
		p = p->next;
	}

	return NULL;
}

void rm_node(node *p)
{
	node *pre = head;

	while (pre->next != NULL)
	{
		if (pre->next == p)
		{
			pre->next = p->next;
			p->next = NULL;
			return;
		}

		pre = pre->next;
	}
}

void reverse_link()
{
	node *nhead = NULL;
	node *p;

	while (head->next != NULL)
	{
		p = head->next;
		head->next = p->next;
		p->next = nhead;
		nhead = p;
	}

	head->next = nhead;
}

void destroy()
{
	node *p;

	while (head->next != NULL)
	{
		p = head->next;
		head->next = p->next;
		free_node(p);
	}
}

int main()
{
	node *p;
	int target;
	p = mk_node(100);
	insert_node_l2b(p); 
	p = mk_node(-2);
	insert_node_l2b(p); 
	p = mk_node(30);
	insert_node_l2b(p); 
	p = mk_node(-4);
	insert_node_l2b(p); 
	p = mk_node(50);
	insert_node_l2b(p); 
	p = mk_node(6);
	insert_node_l2b(p); 

	traverse();

	scanf("%d", &target);
	p = search(target);
	if (p == NULL)
	{
		printf("can't find  %d\n",  target);
	}else
	{
		printf("%p %d %d\n",  p, target, p->item);
		rm_node(p);
		free_node(p);
	}
	traverse();
	reverse_link();
	traverse();
	destroy();
	traverse();
	return 0;
}

链表反转

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
	int item;
	struct node  *next;
}node_t;

node_t *head = NULL;
/*
定义节点
测试节点长度并强制转换为指针类型保持两边的类型一致
分配地址空间，如果空间为空结束程序
如果有空间将目标值放到空间中
将最后一个next赋值为空
*p是啥？？
*/
node_t *mk_node(int item)
{
	node_t *p = (node_t*)malloc(sizeof(node_t));
	if (p == NULL)
	{
		printf("malloc default!");
		exit(1);		
	}
	
	p->item = item;
	p->next = NULL;
}
/*
有了创建节点的函数必须加上释放节点的函数
*/
void free_node(node_t *p)
{
	free(p);
}
/*
将第二个元素插到第一个元素的前面
p在第一个的最前面这时head是空
将p的第二个元素指向第一个的head
将head指向p这时候head是第二个元素
*/
void insert_node(node_t *p)
{
	p->next = head;
	head = p;
}
/*
查找函数
先将指针指向head
判断是否是空指针
如果p指向的item 是target
返回p如果不是就继续查找下一个
如果没有就返回空
*/
node_t *search(int target)
{
	node_t *p = head;
	
	while (p != NULL)
	{
		if (target == p->item)
		{
			return p;
		}
		p = p->next;
	}
	return NULL;
}
void rm_node(node_t *p)
{
	node_t *pre = head;
	
	if (p == head)//gaidong
	{
		head = head->next;
		p->next = NULL;
		return;
	}
	
	while( pre->next != NULL)
	{
		if (pre->next == p)
		{
			pre->next = p->next;
			return;
		}
		pre = pre->next;
	}
}
void destroy()
{
	node_t *p;
	
	while(head != NULL)
	{
		p = head;
		head = head->next;
		free_node(p);
	}
}
/* 
遍历性
先将head给指针
将检测到的每个item输出
将p指向下一个p
*/
void traverse()
{
	node_t *p = head;
	
	while(p != NULL)
	{
		printf("%d",p->item);
		p = p->next;
	}
	printf("\n");
}
void reverse()
{
	node_t *nhead = NULL;
	node_t *p;
	
	while (head != NULL)
	{
		p = head;
		head = head->next;
		p->next = nhead;
		nhead = p; 
	}
	head = nhead;
}
int main()
{
	node_t *p;
	int target;
	p = mk_node(1);
	insert_node(p);
	p = mk_node(2);
	insert_node(p);
	p = mk_node(3);
	insert_node(p);
	p = mk_node(4);
	insert_node(p);
	
	traverse(); 
	printf("please give me a number !\n"); 
	scanf("%d",&target);
	p = search(target);
	if (p == NULL)
	{
		printf("can't find %d\n",target);
	}else
	{
		printf("%p %d %d\n",p,target,p->item);
		rm_node(p);
		free_node(p);
	}
	traverse();
	reverse();
	traverse();
	destroy();
	traverse();
	
	return 0;
}

双向链表

#ifndef DOUBLYLINKEDLIST_H
#define DOUBLYLINKEDLIST_H

typedef struct node *link;
struct node
{
	unsigned char item;
	link prev, next;
};

link make_node(unsigned char item);
void free_node(link p);
link search(unsigned char key);
void insert(link p);
void delete(link p);
void traverse(void (*visit)(link));
void destroy(void);
void enqueue(link p);
link dequeue(void);

#endif




#include <stdio.h>
#include "doublylinkedlist.h"
//声明 

void print_item(link p)
{
	printf("%d\n", p->item);
}

int main(void)
{
	link p = make_node(10);
	insert(p);
	p = make_node(5);
	insert(p);
	p = make_node(90);
	insert(p);
	p = search(5);
	delete(p);
	free_node(p);
	traverse(print_item);
	destroy();

	p = make_node(100);
	enqueue(p);
	p = make_node(200);
	enqueue(p);
	p = make_node(250);
	enqueue(p);
	while (p = dequeue())
	 {
		print_item(p);
		free_node(p);
	}

	return 0;
}

#include <stdlib.h>
#include "doublylinkedlist.h"//引用自身 

struct node tailsentinel;
struct node headsentinel = {0, NULL, &tailsentinel};
struct node tailsentinel = {0, &headsentinel, NULL};

static link head = &headsentinel;
static link tail = &tailsentinel;

link make_node(unsigned char item)
{
	link p = malloc(sizeof *p);
	p->item = item;
	p->prev = p->next = NULL;
	return p;
}

void free_node(link p)
{
	free(p);
}

link search(unsigned char key)
{
	link p;
	for (p = head->next; p != tail; p = p->next)
	{
		if (p->item == key)
			return p;
	}

	return NULL;
}

void insert(link p)
{
	p->next = head->next;
	head->next->prev = p;
	head->next = p;
	p->prev = head;
}

void delete(link p)
{
	p->prev->next = p->next;
	p->next->prev = p->prev;
}

void traverse(void (*visit)(link))
{
	link p;
	for (p = head->next; p != tail; p = p->next)
	{
		visit(p);
	}
}

void destroy(void)
{
	link q, p = head->next;
	head->next = tail;
	tail->prev = head;

	while (p != tail)
	{
		q = p;
		p = p->next;
		free_node(q);
	}
}

void enqueue(link p)
{
	insert(p);
}

link dequeue(void)
{
	if (tail->prev == head)
	{
		return NULL;
	}
	else
	{
		link p = tail->prev;
		delete(p);
		return p;
	}
}
不负过往霓
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
XCPC第四站！链表+栈和队列+kmp一网打尽！
m0_73401638的博客
01-24 437
这是XCPC系列的第四篇文章，讲解了链表、栈和队列以及kmp算法的内容。
大数阶乘 双向链表
03-08
本主题聚焦于如何使用双向链表这一数据结构来实现大数阶乘的计算。双向链表允许我们有效地存储和操作大数，同时保持良好的性能。 首先，我们需要了解双向链表的基本概念。双向链表是一种线性数据结构，其中每个节点...
week4 KMP+链表+栈+队列
weixin_52694528的博客
10-04 128
一、KMP next数组的作用：存储模式串每个位置的最长公共前后缀的长度是多少，之后在移动模式串指针的时候，当p[j]!=s[i]时（p模式串，s主串），指针j可以快速移动，即j=next[j]。 为什么？ 题目：​​​​​活动 - AcWing #include<iostream> #include<string> using namespace std; const int N=1e5+10,M=1e6+10; int ne[N]; int main() { in.
模拟单向双向链表、模拟栈与队列、KMP
ll793332773的博客
11-03 152
一、模拟链表 单链表 模拟单链表 #include<bits/stdc++.h> using namespace std; const int N = 1e5+10; int head,ne[N],e[N],idx; int n; // head 指向头节点 // ne[i]指向第i个节点的下一个节点 // e[i] 第i个节点的值 // idx 存储当前已经用到了哪个点 void init() { head = -1; idx=0; } //将x插到头节点 void add_
数据结构学习笔记- 基于链表的KMP算法
LucasGao14的博客
02-14 1012
基于链表的KMP算法 数据结构学习笔记 模式串 pattern 需要匹配的串称为模式串 需求分析 查找首个与pattern匹配的子表 DoubleNode<T> search(DoublyList<T> pattern) 数据结构的声明 public class DoublyList<T> extends Object{ private Double...
单向双向链表实现
技术偏执怪
09-26 214
简单的实现了单双链表，data部分可创建一个新类储存数据
算法笔记4.链表，栈与队列，kmp
fadaoge的博客
03-19 419
一般链表都是结构体加指针实现（动态链表，效率慢），但是这是算法的笔记，所以为了效率考虑是用数组模拟的。
java 约瑟夫问题 链表_027-环形链表介绍和约瑟夫问题
weixin_34479122的博客
02-25 60
2.网上数据结构和算法的课程不少，但存在两个问题：1)授课方式单一，大多是照着代码念一遍，数据结构和算法本身就比较难理解，对基础好的学员来说，还好一点，对基础不好的学生来说，基本上就是听天书了2)说是讲数据结构和算法，但大多是挂羊头卖狗肉，算法讲的很少。 本课程针对上述问题，有针对性的进行了升级3)授课方式采用图解+算法游戏的方式，让课程生动有趣好理解4)系统多面的讲解了数据结构和算法, 除常用数...
史上最全面Java面试汇总（面试题+答案）
热门推荐
二十同学
07-06 9万+
JAVA面试精选【Java基础第一部分】 JAVA面试精选【Java基础第二部分】 JAVA面试精选【Java基础第三部分】 JAVA面试精选【Java算法与编程一】 JAVA面试精选【Java算法与编程二】 Java高级工程师—面试(1) Java高级工程师—面试(2) Java高级工程师—面试(3) BAT/网易等面试心得 阿里历年面试题 Java中高级面试题 数据...
tushu_visualc++_图书管理_
09-28
同时，为了高效地查询和管理这些信息，可能还会使用到如链表、树或者哈希表等数据结构。 此外，搜索算法也是查询功能的关键。基本的线性搜索在大数据量下效率较低，因此通常会采用二分查找、哈希索引等方式提高查询...
数据结构实验+报告.rar
02-19
1. **实验1**：通常，实验一开始会介绍基础的数据结构概念，如数组、链表等，可能会要求学生用C语言实现简单的数据操作，如插入、删除和遍历。 2. **实验2**：这一阶段可能涉及到更复杂的数据结构，如栈和队列，...
双向链表算法.zip
04-24
常见的字符串匹配算法包括暴力匹配、KMP算法、Boyer-Moore算法等。 这些是计算机科学中常见的算法类型，每种算法都有不同的应用场景和解决问题的方法。在实际编程中，选择合适的算法对于提高程序效率和性能至关重要...
sedgewick-cpp：Robert Sedgewick的C ++算法演练
01-29
5. **数据结构**：如链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、哈希表等。这些数据结构是算法的基石，不同的数据结构适用于不同的问题场景，选择合适的数据结构能显著提高算法效率。 6. **递归与回溯**...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 870
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 176
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 329
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 259
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
链表实现kmp算法c语言
01-02
抱歉，根据提供的引用内容，没有找到关于链表实现KMP算法的C语言示例。KMP算法主要用于字符串匹配，而链表是一种数据结构，两者在实现上没有直接的联系。如果您需要了解如何在C语言中实现KMP算法，我可以为您提供一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值