【数据结构回顾】

已于 2023-09-03 09:59:09 修改
阅读量691 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2023-09-01 10:09:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42733748/article/details/132617873
版权

数据结构回顾

一、单链表

在这里插入图片描述

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

typedef struct Node {
	int data;
	Node *next;
}Node;

Node* initList()
{
	Node *list = (Node*)malloc(sizeof(Node));
	list->data = 0;
	list->next = NULL;
	return list;
}

void headInsert(Node* L, int data)
{
	Node *node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = L->next;
	L->next = node;
	L->data++;
}

void tailInsert(Node* L, int data)
{
	Node *List = L;
	Node *node = (Node*)malloc(sizeof(Node));
	node->data = data;
	while (List->next)
	{
		List = List->next;
	}
	node->next = List->next;
	List->next = node;
	L->data++;
}

int delete_node(Node* L, int data)
{
	Node *pre = L;
	Node *current = L->next;

	while(current)
	{
		if (current->data==data)
		{
			pre->next = current->next;
			free(current);
			L->data--;
			return true;
		}
		else
		{
			pre = current;
			current = current->next;
		}
	}
	return false;
}

void printList(Node* L)
{
	while (L->next)
	{
		L = L->next;
		printf("node = %d\n", L->data);
	}
}

int main()
{
	Node* L = initList();
	headInsert(L, 1);
	headInsert(L, 2);
	headInsert(L, 3);
	headInsert(L, 4);
	headInsert(L, 5);
	tailInsert(L, 6);
	tailInsert(L, 7);
	printList(L);

	if (delete_node(L, 3)) {
		printf("success delete\n");
	}
	else {
		printf("fail delete\n");
	}
	printList(L);

	system("pause");
	return 0;
}

二、单循环链表

在这里插入图片描述

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

typedef struct Node {
	int data;
	Node *next;
}Node;

Node* initList() 
{
	Node *L = (Node*)malloc(sizeof(Node));
	L->next = NULL;
	L->data = 0;
	L->next = L;
	return L;
}

void headInsert(Node* L, int data)
{
	Node *node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = L->next;
	L->next = node;
	L->data++;
}

void tailInsert(Node* L, int data)
{
	Node *List = L;
	Node *node = (Node*)malloc(sizeof(Node));
	while (List->next!=L)
	{
		List = List->next;
	}
	node->data = data;
	node->next = L;
	List->next = node;
	L->data++;
}

int delete_node(Node* L, int data)
{
	Node *pre = L;
	Node *current = L->next;
	while (current!=L)
	{
		if (current->data == data)
		{
			pre->next=current->next;
			free(current);
			L->data--;
			return true;
		}
		else
		{
			pre = current;
			current = current->next;
		}	
	}
	return false;
}

void printList(Node* L)
{
	Node *node = L->next;
	while (node !=L)
	{
		printf("%d->", node->data);
		node=node->next;
	}
	printf("NULL\n");
}
int main()
{
	Node* L = initList();
	headInsert(L, 1);
	headInsert(L, 2);
	headInsert(L, 3);
	headInsert(L, 4);
	headInsert(L, 5);
	tailInsert(L, 6);
	tailInsert(L, 7);
	printList(L);
	delete_node(L, 4);
	delete_node(L, 7);
	printList(L);

	system("pause");
	return 0;
}

三、双链表

在这里插入图片描述

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

typedef struct Node {
	int data;
	Node *pre;
	Node *next;
}Node;

Node* initList() 
{
	Node *L=(Node*)malloc(sizeof(Node));
	L->data = 0;
	L->next = NULL;
	L->pre = NULL;
	return L;
}

void headInsert(Node* L, int data)
{
	Node *node= (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = L->next;
	node->pre = L;
	if (L->next!=NULL)
	{
		L->next->pre = node;
	}
	L->next = node;
	L->data++;
}

void tailInsert(Node* L, int data)
{
	Node *n = L;
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	while (n->next)
	{
		n = n->next;
	}
	node->next = n->next;
	node->pre = n;
	n->next = node;
	L->data++;
}

int delete_Node(Node* L, int data)
{
	Node* n = L->next;
	while (n)
	{
		if (n->data == data)
		{
			n->pre->next = n->next;
			if (n->next != NULL)
			{
				n->next->pre = n->pre;
			}
			free(n);
			L->data--;
			return true;
		}
		else
		{
			n = n->next;
		}
	}
	return false;
}

void printList(Node* L)
{
	Node *n = L->next;
	while (n)
	{
		printf("%d -> ", n->data);
		n = n->next;
	}
	printf("NULL\n");
}

int main()
{
	Node *L= initList();
	headInsert(L, 1);
	headInsert(L, 2);
	headInsert(L, 3);
	headInsert(L, 4);
	tailInsert(L, 5);
	tailInsert(L, 6);
	printList(L);
	delete_Node(L, 6);
	printList(L);
	delete_Node(L, 3);
	printList(L);

	system("pause");
	return 0;
}

四、双循环链表

在这里插入图片描述

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

typedef struct Node {
	int data;
	Node *pre;
	Node *next;
}Node;

Node * initList()
{
	Node * L = (Node*)malloc(sizeof(Node));
	L->data = 0;
	L->next = L;
	L->pre = L;
	return L;
}

void headInsert(Node* L, int data)
{
	Node *node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = L->next;
	node->pre = L;
	L->next->pre = node;
	L->next = node;
	L->data++;
}

void tailInsert(Node* L, int data)
{
	Node *n = L;
	Node* node = (Node*)malloc(sizeof(Node));
	while (n->next != L)
	{
		n=n->next;
	}
	node->data = data;
	node->next = n->next;
	node->pre = n;
	n->next->pre = node;
	n->next = node;
	L->data++;
}

int delete_Node(Node* L, int data)
{
	Node* n=L->next;
	while (n!=L)
	{
		if (n->data == data)
		{
			n->pre->next = n->next;
			n->next->pre = n->pre;
			free(n);
			L->data--;
			return true;
		}
		n = n->next;
	}
	return false;
}

void printList(Node* L)
{
	Node *n = L->next;
	while (n!=L)
	{
		printf("%d -> ",n->data);
		n=n->next;
	}
	printf("NULL\n");
}

int main()
{
	Node* L = initList();
	headInsert(L, 1);
	headInsert(L, 2);
	headInsert(L, 4);
	headInsert(L, 5);
	printList(L);
	tailInsert(L, 6);
	tailInsert(L, 7);
	printList(L);
	delete_Node(L, 7);
	printList(L);
	delete_Node(L, 4);
	printList(L);

	system("pause");
	return 0;
}

五、栈（先进后出）

在这里插入图片描述
在这里插入图片描述

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

typedef struct Node {
	int data;
	Node *next;
}Node;

Node *initStack()
{
	Node *S = (Node*)malloc(sizeof(Node));
	S->next = NULL;
	S->data = 0;
	return S;
}

void push(Node *S, int data)
{
	Node *node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = S->next;
	S->next = node;
	S->data++;
}


void printStack(Node *S)
{
	Node* node = S->next;
	while (node)
	{
		printf("%d --> ",node->data);
		node = node->next;
	}
	printf("NULL\n");
}

int isEmpty(Node *S)
{
	if (S->next == NULL||S->data==0)
	{ 
		return 1;
	}
	else
	{
		return 0;
	}
}

int pop(Node *S)
{
	if (isEmpty(S))
		return -1;
	Node *node = S->next;
	S->next = node->next;
	int data = node->data;
	free(node);
	S->data--;
	return data;
}

int main()
{
	Node *stack = initStack();
	push(stack, 1);
	push(stack, 2);
	push(stack, 3);
	push(stack, 4);
	printStack(stack);
	printf("pop = %d\n", pop(stack));
	printStack(stack);
	printf("pop = %d\n", pop(stack));
	printStack(stack);
	push(stack, 5);
	push(stack, 6);
	push(stack, 7);
	push(stack, 8);
	printStack(stack);

	system("pause");
	return 0;
}

六、队列（先进先出）

在这里插入图片描述

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

typedef struct Node{
	int data;
	Node *next;
}Node;

Node *initQueue()
{
	Node *Q = (Node*)malloc(sizeof(Node));
	Q->next = NULL;
	Q->data = 0;
	return Q;
}

void enQueue(Node *Q,int data)
{
	Node *q = Q;
	Node *node = (Node*)malloc(sizeof(Node));
	node->data = data;
	int value = Q->data;
	while (value--)
	{
		q=q->next;
	}
	node->next = q->next;
	q->next = node;
	Q->data++;
}

int isEmpty(Node *Q)
{
	if (Q->data == 0 || Q->next == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int deQueue(Node *Q)
{
	Node *node = Q->next;
	if (isEmpty(Q))
		return -1;
	int data = node->data;
	Q->next = node->next;
	free(node);
	Q->data--;
	return data;
}

void printQueue(Node *Q)
{
	Node *node = Q->next;
	while (node)
	{
		printf("%d --> ",node->data);
		node = node->next;
	}
	printf("NULL\n");
}

int main()
{
	Node * q = initQueue();
	enQueue(q, 1);
	enQueue(q, 2);
	enQueue(q, 3);
	enQueue(q, 4);
	printQueue(q);
	printf("dequeue = %d\n", deQueue(q));
	printf("dequeue = %d\n", deQueue(q));
	printQueue(q);
	printf("dequeue = %d\n", deQueue(q));
	printf("dequeue = %d\n", deQueue(q));
	printQueue(q);
	enQueue(q, 1);
	enQueue(q, 2);
	enQueue(q, 3);
	printf("dequeue = %d\n", deQueue(q));
	printf("dequeue = %d\n", deQueue(q));
	printQueue(q);
	enQueue(q, 5);
	enQueue(q, 6);
	printQueue(q);

	system("pause");
	return 0;
}

七、循环队列

在这里插入图片描述

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

#define MAXSIZE 5

typedef struct Queue {
	int front;
	int real;
	int data[MAXSIZE];
}Queue;

Queue* initQueue()
{
	Queue *q = (Queue*)malloc(sizeof(Queue));
	q->front = q->real = 0;
	return q;
}

void printQueue(Queue* Q) 
{
	int length = (Q->real - Q->front + MAXSIZE) % MAXSIZE;
	int index = Q->front;
	while (length--)
	{
		printf("%d --> ", Q->data[index]);
		index = (index + 1) % MAXSIZE;
	}
	printf("NULL\n");
}

int isFull(Queue* Q)
{
	if ((Q->real + 1) % MAXSIZE == Q->front)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int isEmpty(Queue* Q)
{
	if (Q->front==Q->real)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int enQueue(Queue* Q, int data)
{
	if (isFull(Q))
		return -1;
	Q->data[Q->real] = data;
	Q->real = (Q->real + 1) % MAXSIZE;
	return 0;
}

int deQueue(Queue* Q)
{
	if (isEmpty(Q))
		return -1;
	int data = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;
	return data;
}

int main()
{
	Queue* Q = initQueue();
	enQueue(Q, 1);
	enQueue(Q, 2);
	enQueue(Q, 3);
	enQueue(Q, 4);
	printQueue(Q);
	printf("dequeue = %d\n", deQueue(Q));
	printQueue(Q);
	printf("dequeue = %d\n", deQueue(Q));
	printQueue(Q);
	enQueue(Q, 5);
	enQueue(Q, 6);
	enQueue(Q, 7);
	printQueue(Q);
	
	system("pause");
	return 0;

}

八、冒泡排序

#include <stdio.h>

void printArray(int array[], int length)
{
	for (int i = 0; i < length; i++)
	{
		printf("%d ",array[i]);
	}
	printf("\n");
}

void bubbleSort(int array[], int length)
{
	for (int j = 0; j < length-1; j++)
	{
		for (int i = 0; i < length-1-j; i++)
		{
			if (array[i] > array[i + 1])
			{
				int temp = array[i];
				array[i] = array[i + 1];
				array[i + 1] = temp;
			}
		}
		printArray(array,length);
	}
}

int main()
{
	int array[8] = { 49, 38, 65, 97, 76, 13, 27, 49 };
	bubbleSort(array, 8);

	return 0;
}

九、快速排序

#include <stdio.h>
#include <string.h>

void printArray(int array[], int length)
{
	for (int i = 0; i < length; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}

int partition(int array[], int i, int j)
{
	int x = array[i];
	while (i < j)
	{
		while(i<j&&array[j]>=x)
		{
			j--;
		}
		if (i < j)
		{
			array[i] = array[j];
			i++;
		}
		while (i<j&&array[i]<x)
		{
			i++;
		}
		if (i < j)
		{
			array[j] = array[i];
			j--;
		}

	}
	array[i] = x;
	return i;
}

void quickSort(int array[], int i, int j)
{
	if (i < j)
	{
		int index = partition(array,i,j);
		printArray(array, 8);
		quickSort(array,i,index-1);
		quickSort(array, index+1,j);
	}
}

int main()
{ 
	int array[8] = { 27, 38, 13, 49, 76, 97, 65, 49 };
	quickSort(array,0,7);
	return 0;
}
自然醒欧
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构基础
10-01
数据结构回顾
链表的实现
如月之恒，如日之升
07-26 368
第一次画图画累了
数据结构C语言单链表学习记录
Zhang97_的博客
09-17 410
C语言单链表学习记录
2020-03-11
richhappenman的博客
03-11 68
各位大佬，我的这个输入的数据为什么进不了我的链表里呢？ struct Node* createList() { struct Node* List = (struct Node*)malloc(sizeof(struct Node)); List->next = NULL; return List;}struct Node* createNode(struct Message info){ ...
C 链表 从原始到进阶
qq_59193771的博客
01-17 323
#include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; int main() { //创建头指针 struct Node* headNode = (struct Node*)malloc(sizeof(struct Node)); headNode->next = NULL; //插入值 //先创建一格并...
一、【回顾篇】linux基础、C语言、数据结构回顾
十七阿哥的博客
11-02 3076
一、linux基础、C语言、数据结构回顾 目录一、linux基础、C语言、数据结构回顾1、linux基础：2、Linux下的C语言3、面试题4、linux下数据结构5、Linux下高级编程6、结构7、物联网项目框架8、现如今物联网技术9、由表象到里象了解芯片10、了解芯片10、ARM公司和ST公司11、了解STM32F103RBT6芯片 1、linux基础： 熟悉Linux环境、Red Hat centos suse ubuntu …、安装操作系统、命令、服务、权限、vim gcc 2、Linux下的C语言
删除链表中的节点(实现的函数只给一个参数)（数据结构回顾）
ambiguous__的博客
06-29 4188
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。 现有一个链表 -- head = [4,5,1,9]，它可以表示为: 示例 1: 输入: head = [4,5,1,9], node = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2: 输入: head = [4,5,1,9], node = 1 输出: [4,5,9] 解释: 给定你链.
数据结构回顾——几类线性表对比与总结
只要思想不滑坡，想法总比问题多。
08-27 948
顺序表、单链表、双向链表、循环链表、静态链表等几类线性表，各自具有固有的特点、优缺点，决定其适用于不同的应用场景。
高级数据结构总结
qq_46038405的博客
11-03 3119
高级数据结构总结 前期回顾：常用数据结构总结       仅仅掌握好它们是不足以应对大厂的算法面试的，很多大厂的算法面试题都涉及到了大数据、图论以及动态规划的数据等，这些问题如果只凭借常用数据结构来解决的话，是很难达到理想的时间和空间复杂度要求的。 1.1 高级数据结构 1.2 优先队列 / Priority Queue 1.3 图 / Graph 1.4 前缀树 / Trie 1.5 线段树 / Segment Tree 1.6 树状数组 /
数据结构C语言表达式求值
01-02
（3）保留历史分数，能回顾历史，给出与历史分数比较后的评价 （4）有合理的提示； （5）有非法数据的判断； 测试数据及测试结果请在上交的资料中写明。 首先构造的两个结构题模块：struct Quesstion和struct ...
datastructure:回顾数据结构
05-09
回顾数据结构 关于数据结构与算法，一直学习ing 附带数据结构排序类算法wiki的连接 关数据结构与算法，我的理解，跟数学类似，首先你要明白这个公式，然后多做练习，明白什么时候用就行了。 至于具体实现到什么程度...
数据结构期末复习ppt
03-12
数据结构期末复习ppt提纲，主要是对课程内容的重点概念回顾
数据结构与算法——知识点总结
热门推荐
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
C++的数据结构(三）：栈
最新发布
全栈工程师Linda的博客
05-12 411
C++的数据结构(三）：栈及实例
【初级数据结构】队列
2301_77112794的博客
05-12 815
本文主要介绍了队列的基本结构和实现
多年后，再探算法和数据结构
qq_52010229的博客
05-09 439
多年来，通过深入学习和实践各种编程语言，我对数据结构和算法在程序设计中的中心地位有了新的认识。本次从汇编语言到高级编程语言的探讨，展示了无论技术如何进步，构成程序的核心—算法和数据结构—始终保持其基础和不变的角色。
【数据结构】单链表专题详细分析
Become Mad的博客
05-10 1265
学习完了顺序表，我们发现对顺序表的增删查改存在一定的缺点，那有没有更好的数据结构可以更好地解决问题呢？那就进来看看吧~
相交链表（数据结构）
Jason_from_China的博客
05-08 461
160. 相交链表 - 力扣（LeetCode）
数据结构思维onenote
09-06
对于数据结构的思维，可以使用OneNote来进行整理和记录。OneNote是一个非常强大的笔记和信息管理工具，可以帮助您创建和组织...总之，使用OneNote可以帮助您方便地记录和整理数据结构思维，并且轻松地进行查找和回顾。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

自然醒欧

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

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

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

打赏作者

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

抵扣说明：

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

余额充值