MyCDay10

MyCDay10

链表的实现

List.h

#pragma once 

//编程的接口（API）
//  *.h 文件中一般会放：类型的定义，函数的声明，全局变量

#include <stdbool.h>

typedef struct node {
	int val;
	struct node* next;

}Node;

typedef struct {
	Node* head;
	Node* tail;
	int size;
}List;

List* create_list();//创建
void destroy_list();//删除

void add_before_head(List* list, int val);//头插
void add_behind_tail(List* list, int val);//尾插
void add_node(List* list, int idx, int val);//插入结点

bool delete_node(List* list, int val); //删除结点

int find_by_index(List* list, int idx);  //按位查找
Node* search(List* list, int  val);  //按值查找

List.c

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

//创建空的链表
List* create_list() {
	return calloc(1, sizeof(List));
}

//释放资源
void destroy_list(List* list) {
	if (list == NULL) {
		return;
	}
	//先释放所有Node
	Node* curr = list->head;
	while (curr != NULL) {
		Node* next = curr->next;
		free(curr);
		curr = next;
	}
	//释放List结构
	free(list);
}

//头插法
void add_before_head(List* list, int val) {
	//创建结点
	Node* newNode = malloc(sizeof(Node));
	if (newNode == NULL) {
		printf("malloc failed in add_before_head\n");
		exit(1);
	}
	// 初始化
	newNode->val = val;
	newNode->next = list->head;
	//更新list的信息
	list->head = newNode;
	if (list->size == 0) {
		list->tail = newNode;
	}
	list->size++;
}

//尾插法
void add_behind_tail(List* list, int val) {
	//创建借点
	Node* newNode = malloc(sizeof(Node));
	if (newNode == NULL) {
		printf("malloc failed in add_before_head\n");
		exit(1);
	}
	//初始化结点
	newNode->val = val;
	newNode->next = NULL;
	//链接
	if (list->size != NULL) {
		list->tail->next = newNode;
	}
	//更新list信息
	if (list->size == 0) {
		list->head = newNode;
	}
	list->tail = newNode;
	list->size++;
}

void add_node(List* list, int idx, int val) {
	//1.参数校验
	if (idx < 0 || idx > list->size) {
		printf("Illegal argument: idx = %d\n", idx);
		return;
	}
	//头插
	if (idx == 0) {
		add_before_head(list, val);
		return;
	}
	//尾插
	if (idx == list->size) {
		add_behind_tail(list, val);
		return;
	}

	//中间插入
	//1.创建结点
	Node* newNode = malloc(sizeof(Node));
	if (newNode == NULL) {
		printf("malloc failed in add\n");
		exit(1);
	}
	//2.初始化结点
	newNode->val = val;
	//3.找索引为idx- 1的结点
	Node* curr = list->head;
	//循环不变式：curr指向结点的索引为idx-2
	for (int i = 0; i < idx - 1; i++) {
		curr = curr->next;
	}

	newNode->next = curr->next;
	curr->next = newNode;
	list->size++;
}

//根据索引查找值
int find_by_index(List* list, int idx) {
	//校验参数
	if (idx < 0 || idx >= list->size) {
		printf("illegal argument :idx= %d\n", idx);
		return -1;
	}
	Node* curr = list->head;
	for (int  i = 0; i < idx; i++)
	{
		curr = curr->next;
	}
	return curr->val;	
}

//查找与特定值相等的结点
Node* search(List* list, int val) {
	Node* curr = list->head;
	while (curr != NULL) {
		if (curr->val == val) {
			return curr;
		}
		curr = curr->next;
	}
	return NULL;
}

//删除第一个值等于val的值
bool delete_node(List* list, int val) {
	Node* prev = NULL;
	Node* curr = list->head;
	while (curr != NULL) {
		if (curr->val == val) {
			//头
			if (prev == NULL) {
				list->head = curr->next;
				//只有一个结点
				if (list->size == 1) {
					list->tail = NULL;
				}
				list->size--;
				free(curr);
			}
			else{
				prev->next = curr->next;
				if (curr->next == NULL) {
					list->tail = prev;
				}
				list->size--;
				free(curr);
			}
			return true;
		}
		prev = curr;
		curr = curr->next;
	}
	return false;
}

main.c

#include "List.h"

int main(void) {
	List* list = create_list();
	add_node(list, 0, 100);
	add_node(list, 0, 200);
	add_node(list, 2, 300);
	add_node(list, 1, 400);//200->400->100->300

	bool flag = delete_node(list, 200);
	flag = delete_node(list, 200);
	flag = delete_node(list, 100);

	destroy_list(list);



	return 0;
}

栈

栈的实现

栈的应用

• 1.函数调用栈
• 2.符号匹配问题
  • 入栈：遇到左括号
  • 出栈：遇到右括号

算法思想：

1. 遇到左括号，将对应的右括号入栈
2. 遇到右括号，出栈；将出栈的括号与遇到右括号比较；相等：继续处理；不相等：不匹配；
3. 将所有字符处理完后，返回栈是否为空

• 3.DFS（Depth First Search）
• 4.表达式求值

1+2*3 //中缀表达式
123*+ //后缀表达式
//例子：
1+2*3-4*5
123*+45*-

• 如何计算后缀表达式？
• 如何将中缀表达式转换成后缀表达式？

队列

• 队列：“操作受限”的线性表，一端插入一端删除，特性是FIFO。

1.队头索引为0 ； 数组长度为N
* 入队列：O（1）
* 出队列：O（n）
* 判空：rear==0
* peek：elements[0]
* full:rear == N

2.双指针队列

• enqueue：O(1)
• dequeue:O(1)
• peek:elements[front]
• isEmpty:fron t== rear
• isFull:rear == N
• 缺点：内存利用率低

3.循环数组

• 头指针：front=(front+1)%N
• 尾指针：rear=(rear+1)%N
• enqueue:O(1)
• dequeue:O(1)
• peek:elements[front]
• isEmpty:front==rear
• isFull:front==rear

• 如何区分空和满的情况？
  1 isFull:(rear+1)%N== front
  2 添加一个size属性
  isEmpty: size == 0
  isFull: size==N