C语言链表操作

已于 2023-08-14 00:28:46 修改
阅读量283 收藏
点赞数
文章标签： 链表 c语言 数据结构
于 2023-08-13 23:07:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49001476/article/details/132265255
版权

目录

链表基本操作

删除重复元素 

查找倒数第N个节点

查找中间节点

约瑟夫环

循环链表

合并有序链表

逆置链表

逆置链表(双向链表)

链表基本操作

//linklist.c


#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned char elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
}

void insert_node(int pos, unsigned char elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;

		if(p->next == NULL)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == NULL)
			tail = pre;
		free(p);
	}
}

void print_linklist(void)
{
	struct node *p;
	
	for(p = head; p; p = p->next)
		printf("%c", p->elem);

	printf("\n");
}

int search(unsigned char elem)
{
	struct node *p;

	for(p = head; p; p = p->next)
		if(p->elem == elem)
			return 1;
	return 0;
}

//linklist.h

#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

struct node
{
	unsigned char elem;
	struct node *next;
};

void create_list(unsigned char elem);
void insert_node(int pos, unsigned char elem);
void delete_node(int pos);
void print_linklist(void);
int search(unsigned char elem);

#endif


//main.c


#include <stdio.h>
#include "linklist.h"

int main(void)
{
	create_list('A');
	create_list('B');
	create_list('C');
	create_list('D');
	print_linklist();

	delete_node(0);
	print_linklist();

	insert_node(0, 'F');
	insert_node(2, 'Z');
	print_linklist();

	if(search('C'))
		printf("the elem is found in the linklist\n");
	else
		printf("Can not find it\n");

	return 0;
}

删除重复元素 

//linklist.c

#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;

		if(p->next == NULL)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == NULL)
			tail = pre;
		free(p);
	}
}

void print_linklist(struct node *linklist_head)
{
	struct node *p;

	for(p = linklist_head; p; p = p->next)
		printf("%5d", p->elem);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;

	for(p = head; p; p = p->next)
		if(p->elem == elem)
			return 1;
	return 0;
}

void delete_repeat(struct node *head)
{
	int flag[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

	struct node *p = head;
	struct node *q = NULL;

	flag[p->elem] = 1;

	while(p->next != NULL)
	{
		if(flag[p->next->elem] == 0)
		{
			flag[p->next->elem] = 1;
			p = p->next;
		}
		else
		{
			q = p->next;
			p->next = q->next;
			free(q);
		}
	}
}

//linklist.h


#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *head;
extern struct node *tail;

struct node
{
	unsigned int elem;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(struct node *linklist_head);
int search(unsigned int elem);
void delete_repeat(struct node *head);

#endif


//main.c


#include <stdio.h>
#include "linklist.h"

int main(void)
{
	create_list(1);
	create_list(2);
	create_list(8);
	create_list(2);
	create_list(3);
	create_list(9);
	create_list(4);
	create_list(6);
	create_list(4);
	create_list(8);
	create_list(7);
	create_list(5);
	create_list(2);
	create_list(9);
	create_list(6);
	print_linklist(head);

	delete_repeat(head);
	print_linklist(head);

	return 0;
}

查找倒数第N个节点

//linklist.c

#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;

		if(p->next == NULL)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == NULL)
			tail = pre;
		free(p);
	}
}

void print_linklist(struct node *linklist_head)
{
	struct node *p;

	for(p = linklist_head; p; p = p->next)
		printf("%5d", p->elem);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;

	for(p = head; p; p = p->next)
		if(p->elem == elem)
			return 1;
	return 0;
}

int find_mid(struct node *linklist_head)
{
	struct node *p;
	struct node *q;
	p = q = linklist_head;

	while(p != NULL && p->next != NULL)
	{
		p = p->next->next;
		q = q->next;
	}

	return q->elem;
}

int find_last_nth(struct node *linklist_head, int n)
{
	int i;

	struct node *p;
	struct node *q;

	p = q = linklist_head;

	for(i = 0; i < n-1; i++)
		p = p->next;

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

	return q->elem;
}

//linklist.h


#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *head;
extern struct node *tail;

struct node
{
	unsigned int elem;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(struct node *linklist_head);
int search(unsigned int elem);
int find_mid(struct node *linklist_head);
int find_last_nth(struct node *linklist_head, int n);

#endif


//main.c

#include <stdio.h>
#include "linklist.h"

int main(void)
{
	int n;

	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	create_list(8);
	create_list(9);
	create_list(10);
	print_linklist(head);

	printf("Please enter the last one you want to show:");
	scanf("%d", &n);

	printf("the last n :%d\n", find_last_nth(head, n));

	return 0;
}

查找中间节点

//linklist.c

#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;

		if(p->next == NULL)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == NULL)
			tail = pre;
		free(p);
	}
}

void print_linklist(struct node *linklist_head)
{
	struct node *p;

	for(p = linklist_head; p; p = p->next)
		printf("%5d", p->elem);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;

	for(p = head; p; p = p->next)
		if(p->elem == elem)
			return 1;
	return 0;
}

int find_mid(struct node *linklist_head)
{
	struct node *p;
	struct node *q;
	p = q = linklist_head;

	while(p != NULL && p->next != NULL)
	{
		p = p->next->next;
		q = q->next;
	}

	return q->elem;
}

//linklist.h


#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *head;
extern struct node *tail;

struct node
{
	unsigned int elem;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(struct node *linklist_head);
int search(unsigned int elem);
int find_mid(struct node *linklist_head);


#endif


//main.c

#include <stdio.h>
#include "linklist.h"

int main(void)
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	create_list(8);
	create_list(9);
	create_list(10);
	print_linklist(head);

	printf("mid = %d\n", find_mid(head));

	return 0;
}

约瑟夫环

约瑟夫问题是个著名的问题：N个人围成一圈，第一个人从1开始报数，报M的将被杀掉，下一个人接着从1开始报。如此反复，最后剩下一个，求最后的胜利者。
例如只有三个人，把他们叫做A、B、C，他们围成一圈，从A开始报数，假设报2的人被杀掉。

●首先A开始报数，他报1。侥幸逃过一劫。
●然后轮到B报数，他报2。非常惨，他被杀了
●C接着从1开始报数
●接着轮到A报数，他报2。也被杀死了。
●最终胜利者是C

//linklist.c

#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
	tail->next = head;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
		tail->next = head;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;

		if(p->next == head)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
		tail->next = head;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == head)
			tail = pre;
		free(p);
	}
}

void print_linklist(void)
{
	struct node *p;
	p = head;
	
//	for(p = head; p != head; p = p->next)
//		printf("%d", p->elem);

	do{
		printf("%5d", p->elem);
		p = p->next;
	}while(p != head);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;
	p = head;

//	for(p = head; p; p = p->next)
//		if(p->elem == elem)
//			return 1;
	do{
		if(p->elem == elem)
			return 1;
		p = p->next;
	}while(p != head);

	return 0;
}

//linklist.h


#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *head;
extern struct node *tail;

struct node
{
	unsigned int elem;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(void);
int search(unsigned int elem);

#endif


//main.c


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

int main(void)
{
	int n, k, m;
	int i;
	struct node *p, *q;

	printf("Please enter the number of person:");
	scanf("%d", &n);

	for(i = 1; i <= n; i++)
		create_list(i);
	print_linklist();
	p = head;

	printf("Please enter the start num:");
	scanf("%d", &k);

	while(--k)
		p = p->next;
//	printf("p->elem = %d\n", p->elem);

	printf("Please enter the m:");
	scanf("%d", &m);
	
	if(1 == m)
	{
		for(i = 0; i < n; i++)
		{
			printf("%3d", p->elem);
			p = p->next;
		}
		printf("\n");
	}
	else
	{
		while(n--)
		{
			for(i = 1; i < m - 1; i++)
				p = p->next;
		
			q = p;
			p = p->next;
			printf("%3d", p->elem);
			q->next = p->next;
			free(p);
			p = p->next;
		}
		printf("\n");
	}
	return 0;
}

循环链表

//linklist.c



#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
	tail->next = head;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
		tail->next = head;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;

		if(p->next == head)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
		tail->next = head;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == head)
			tail = pre;
		free(p);
	}
}

void print_linklist(void)
{
	struct node *p;
	p = head;
	
//	for(p = head; p != head; p = p->next)
//		printf("%d", p->elem);

	do{
		printf("%5d", p->elem);
		p = p->next;
	}while(p != head);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;
	p = head;

//	for(p = head; p; p = p->next)
//		if(p->elem == elem)
//			return 1;
	do{
		if(p->elem == elem)
			return 1;
		p = p->next;
	}while(p != head);

	return 0;
}

//linklist.h


#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

struct node
{
	unsigned int elem;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(void);
int search(unsigned int elem);

#endif


//main.c


#include <stdio.h>
#include "linklist.h"

int main(void)
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	print_linklist();

	insert_node(0, 11);
	print_linklist();

	delete_node(6);
	print_linklist();
	delete_node(0);
	print_linklist();
	delete_node(0);
	print_linklist();
	delete_node(4);
	print_linklist();
	

	insert_node(0, 8);
	print_linklist();
	insert_node(5, 9);
	print_linklist();
	insert_node(2, 13);
	print_linklist();
	
	return 0;
}

合并有序链表

//linklist.c



#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;

		if(p->next == NULL)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == NULL)
			tail = pre;
		free(p);
	}
}

void print_linklist(struct node *linklist_head)
{
	struct node *p;

	for(p = linklist_head; p; p = p->next)
		printf("%5d", p->elem);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;

	for(p = head; p; p = p->next)
		if(p->elem == elem)
			return 1;
	return 0;
}

//linklist.h



#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *head;
extern struct node *tail;

struct node
{
	unsigned int elem;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(struct node *linklist_head);
int search(unsigned int elem);

#endif


//main.c



#include <stdio.h>
#include "linklist.h"

int main(void)
{
	struct node *head1 = NULL;
	struct node *head2 = NULL;
	struct node *p = NULL;  //head1
	struct node *q = NULL;	//head2

	create_list(1);
	create_list(9);
	create_list(13);
	create_list(27);
	head1 = head;
	print_linklist(head1);

	head = NULL;
	create_list(3);
	create_list(5);
	create_list(14);
	create_list(81);
	create_list(88);
	create_list(95);
	create_list(99);
	head2 = head;
	print_linklist(head2);

	head = NULL;
	p = head1;
	q = head2;

	while(p && q)
	{
		if(p->elem <= q->elem)
		{
			if(head == NULL)
				head = p;
			else
				tail->next = p;
			tail = p;
			p = p->next;
		
		}
		else
		{
			if(head == NULL)
				head = q;
			else
				tail->next = q;
			tail = q;
			q = q->next;
		}
	}
	tail->next = p?p:q;
	
	print_linklist(head);

	return 0;
}

逆置链表

//linklist.c

#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
		tail->next = p;

	tail = p;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head = p;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->next = pre->next;
		pre->next = p;
	
		if(p->next == NULL)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		free(pre);
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next == NULL)
			tail = pre;
		free(p);
	}
}

void print_linklist(struct node *linklist_head)
{
	struct node *p;

	for(p = linklist_head; p; p = p->next)
		printf("%5d", p->elem);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;

	for(p = head; p; p = p->next)
		if(p->elem == elem)
			return 1;
	return 0;
}

int find_mid(struct node *linklist_head)
{
	struct node *p;
	struct node *q;
	p = q = linklist_head;

	while(p != NULL && p->next != NULL)
	{
		p = p->next->next;
		q = q->next;
	}

	return q->elem;
}

int find_last_nth(struct node *linklist_head, int n)
{
	int i;

	struct node *p;
	struct node *q;

	p = q = linklist_head;

	for(i = 0; i < n-1; i++)
		p = p->next;

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

	return q->elem;
}

void reverse_linklist(struct node *linklist_head)
{
	struct node *p, *n;

	p = linklist_head->next;
	linklist_head->next = NULL;

	while(p->next != NULL)
	{
		n = p->next;
		p->next = linklist_head;
		linklist_head = p;
		p = n;
	}
	p->next = linklist_head;
	linklist_head = p;

	head = linklist_head;
}

//linklist.h


#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *head;
extern struct node *tail;

struct node
{
	unsigned int elem;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(struct node *linklist_head);
int search(unsigned int elem);
int find_mid(struct node *linklist_head);
int find_last_nth(struct node *linklist_head, int n);
void reverse_linklist(struct node *linklist_head);

#endif


//main.c


#include <stdio.h>
#include "linklist.h"

int main(void)
{
	int n;

	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	create_list(8);
	create_list(9);
	create_list(10);
	print_linklist(head);

	reverse_linklist(head);
	print_linklist(head);

	return 0;
}

逆置链表(双向链表)

//linklist.c



#include "linklist.h"
#include <stdlib.h>

struct node *head = NULL;
struct node *tail = NULL;

void create_list(unsigned int elem)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	p->elem = elem;
	p->pre = NULL;
	p->next = NULL;

	if(head == NULL)
		head = p;
	else
	{
		tail->next = p;
		p->pre = tail;
	}
	tail = p;
}

void insert_node(int pos, unsigned int elem)
{
	struct node *pre;
	pre = head;
	int i = 0;
	struct node *p = (struct node *)malloc(sizeof(struct node));

	if(pos == 0)
	{
		p->elem = elem;
		p->next = head;
		head->pre = p;
		p->pre = NULL;
		head = p;
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}

		p->elem = elem;
		p->pre = pre;
		p->next = pre->next;
		if(p->next != NULL)
			pre->next->pre = p; 
		pre->next = p;

		if(p->next == NULL)
			tail = p;
	}
}

void delete_node(int pos)
{
	struct node *pre, *p;
	pre = head;
	int i = 0;

	if(pos == 0)
	{
		head = head->next;
		head->pre = NULL;
		free(pre);
	}
	else
	{
		while(i < pos - 1)
		{
			pre = pre->next;
			i++;
		}
	
		p = pre->next;
		pre->next = p->next;
		if(p->next != NULL)
			p->next->pre = pre;
		else//if(p->next == NULL)
			tail = pre;
		free(p);
	}
}

void print_linklist(void)
{
	struct node *p;
	
	for(p = head; p; p = p->next)
		printf("%5d", p->elem);

	printf("\n");
}

int search(unsigned int elem)
{
	struct node *p;

	for(p = head; p; p = p->next)
		if(p->elem == elem)
			return 1;
	return 0;
}

void reverse_print_linklist(void)
{
	struct node *p;

	for(p = tail; p; p = p->pre)
		printf("%5d", p->elem);
	printf("\n");
}

//linklist.h


#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

struct node
{
	unsigned int elem;
	struct node *pre;
	struct node *next;
};

void create_list(unsigned int elem);
void insert_node(int pos, unsigned int elem);
void delete_node(int pos);
void print_linklist(void);
int search(unsigned int elem);
void reverse_print_linklist(void);

#endif


//main.c



#include <stdio.h>
#include "linklist.h"

int main(void)
{
	create_list(1);
	create_list(2);
	create_list(3);
	create_list(4);
	create_list(5);
	create_list(6);
	create_list(7);
	print_linklist();

	reverse_print_linklist();
/*
	insert_node(0, 11);
	print_linklist();

	delete_node(6);
	print_linklist();
	delete_node(0);
	print_linklist();
	delete_node(0);
	print_linklist();
	delete_node(4);
	print_linklist();
	

	insert_node(0, 8);
	print_linklist();
	insert_node(5, 9);
	print_linklist();
	insert_node(2, 13);
	print_linklist();
*/	
	return 0;
}

陈学弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
C语言链表超详解
k666499436的博客
05-17 10万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
c语言 链表基本操作
weixin_63178060的博客
08-29 8125
当链表不为空时，则需循环遍历链表，找到链表中最后一个结点，然后将其的next域指向新节点，即cur->next=newnode，此时，不需要将新节点的next域赋值为空，因为在创建结点函数中已将next域赋值为空。在进行头插元素的时候，第一步和第二步不能进行交换，如果先进pre->next=s,此时pre->next指向了s,在进行s->next=pre->next，就会使s->next指向自己本身，无法达到预期效果。如果给定位置正常，则直接将给定位置的next指向，给定位置的next的next。...
C语言 链表操作题
laocooon的博客
12-24 1545
（1）用一个单向链表接收一个长字符串，且每个节点接收一个字符，遍历输出链表中的所有字符，并将字符串无冗余地存放到一个动态存储分配的的字符数组中，并且输出该字符串。（本题暂不考虑空字符串情况）(结尾以回车结束) （2）再输入一个字符，如果该字符已在链表中，则删除该结点，否则在输入字符和结点的数据域字符差值最小的结点后面插入包含该字符的结点，输出最后的字符串。 建立链表 插入元素 遍历 输出 数组 遍历查找 找到则删 没找到就求位置 输出链的内容 要求：采用模块化设计方法，将创建链..
C语言实现链表基本操作
qq_56066173的博客
08-20 4296
如果把数据比喻成珠子，指针就是线，链表通过指针这条线就是把数据这些珠子串起来。
C语言操作链表详解
Violet277的博客
10-28 2334
C语言操作链表详解链表的概念链表的操作将数据抽象成结构体创建和初始化链表输出链表中存储的数据查找链表中指定位置中存储的数据在链表中插入数据删除指定位置的数据修改制定位置的数据逆序输出链表存储的数据执行结果 在我们学习C语言的前期，每当我们要进行大量数据的读写时，我们都会使用顺序表，也就数组，它的优点很明显，增删读写操作很简单，易于上手。但当我们对数据的存储理解更加深刻时，我们便会逐渐意识到顺序表也不是万能的，它也有它的缺点：顺序表在内存中的存储时，占用一大块连续的空间，但我们实际在使用时，可能并没有那么大的
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 61万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
C语言链表详解
qq_28576837的博客
06-02 4746
C语言链表详解
C语言链表的删除操作
weixin_46726346的博客
05-11 4713
C语言中链表的删除节点操作，超简单； 懂了之后修改和查找更不在话下
CSDN第一篇博客-C语言链表操作
Alonewaiting
03-31 1830
一个小白的C语言学习成长 第一次写博客，也是一个小白，非计算机专业的小白，想通过一个平台慢慢提高自己，慢慢记录自己的成长，也希望CSDN社区的小伙伴们能够宽容我这样的小白，有什么不对的地方希望各位能见谅。 C语言实现链表的操作 用C语言首先构建链表的一系列的操作，其中包括链表的生成，链表的排序，链表的倒序，改变两两节点指向，头插法，尾插法等基本操作。直接上代码。代码中有详细的注解 5. typ...
c语言链表操作示例分享
09-04
主要介绍了c语言链表操作示例，代码中有注释,需要的朋友可以参考下
C语言——模拟实现库函数atoi
2302_80250536的博客
05-13 401
INT_MAX 和 INT_MIN 是 C语言 的两个预定义宏，代表了整型变量能够存储的最大正整数21474836472^31 − 1）和最小负整数-2^31这个值是相对于二进制补码表示的，也就是说，负数的范围比正数大 1,这两个宏在头文件中定义。
C语言：设计循环队列
Another_Shi的博客
05-18 757
本篇博客是写完LeetCode_662.设计循环队列之后有感而发，于是写下了一些思路和总结。本题用了两种方法来解答——顺序表和链表。
数据结构中时间复杂度的介绍
gygkhd的博客
05-17 757
在计算机科学领域，特别是在数据结构和算法的研究中，时间复杂度是一个非常关键的概念。它表示一个算法执行完成所需要的计算工作量。了解时间复杂度有助于预测程序运行的速度和效率，这对于优化程序和解决大规模数据处理问题尤为重要。时间复杂度通常用大O符号（O-notation）来表示，它描述了算法性能与输入数据之间的关系。大O符号忽略了常数和低阶项，只关注程序执行时间随输入数据规模增长的变化趋势。例如，时间复杂度为O(n)的算法表示执行时间与输入数据的规模成线性关系。
java常见算法
qq_24099547的博客
05-17 183
要求待查询的序列是有序数列, 每个取中间位置的值与目标值进行比较。
数据结构总结与练习题
最新发布
关注收藏，可以私信解决问题！
05-20 232
数据结构：数组、链表、栈、队列、哈希表、树、图。算法：排序（冒泡排序、快速排序、归并排序）、搜索算法、动态规划、贪心算法、图算法。操作系统：进程管理、内存管理、文件系统、输入/输出管理。计算机网络：网络层协议（IP、ICMP）、传输层协议（TCP、UDP）、应用层协议（HTTP、FTP、DNS）。编程语言：基础语法、控制结构、数据类型、面向对象编程、函数式编程。知识点数组：固定大小的连续内存空间。链表：由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。
【数据结构】堆（Heep）
SWsunlight的博客
05-17 1077
堆、堆的实现
数据结构_栈在括号匹配中的应用_代码
Hooray11的博客
05-17 245
【代码】数据结构_栈在括号匹配中的应用_代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈学弟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值