基础数据结构1：实现定长顺序表

1.时间复杂度简单计算

#include<stdio.h>
//时间复杂度
for (int i = 0; i < n; i++)
{
	for (int j = 0; j < n; j++)
	{
		arr[i][j]=1;
	}
}
//O(n)=n+n^2+n^2=2n^2+n


for (int i = 0; i < n; i++)
{
	for (int j = i; j < n; j++)
	{
		arr[i][j] = 1;
	}
}
//O(n)=(n+n^2)/2=n^2

7_15
A基础数据结构
1.时间复杂度以及空间复杂度
2.线性表（顺序表，链表）
3.单链表（刷题，双向链表，循环链表）
4.串（BF（朴素）算法，KMP算法）
5.栈
6.队列
以上为基础数据结构，面试经常被问到，比较简单，用到的也最多
B算法：
1.直接插入排序
2.希尔排序
3.选择排序
4.冒泡排序
5.归并排序
6.基数排序
7.快速排序
8.堆排序

C高级数据结构
1.树
2.图
3.检索（搜索）
D数据结构：
（1）集合
（2）线性结构
① 存在惟一的一个被称做“第一个”的数据元素;
② 存在惟一的一个被称做“最后一个”的数据元素;
③ 除第一个之外,集合中的每个数据元素均只有一个前驱；
④ 除最后一个之外,集合中每个数据元素均只有一个后继。
（3）树形结构
（4）图状结构或网状结构（交通网络，六度分割理论）
E时间复杂度：语句与问题规模之间的函数关系
经常遇到的时间复杂度
（1）O(1)没有循环，要么有循环，但是循环退出条件和问题规模之间没有关系——循环次数是一个常数
（2）O(n)有循环，并且循环的次数与问题规模之间没有关系（控制循环的变量每次+1或者-1来执行）
（3）O(n^2)循环嵌套
（4）O(logn)油循环，并且循环次数与问题规模之间有关系（控制循环的变量每次*2，或者/2来执行）
时间复杂度的省略（渐变）规则：
1.只看最高项
2.不要系数
F空间复杂度：算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作S(n)=O(f(n))，函数所需要的额外（除函数数据计算本身的存储空间之外）的存储空间与问题规则之间的函数关系。
二路归并排序：空间复杂度为O(n)
G线性表
唯一的头，唯一的尾，除头之外都有唯一的前驱，除尾之外其他节点都有唯一的后继节点
线性表有两种数据结构来实现：

1.顺序表：权限更多的数组
功能： 读写 插入 删除 判空 判满 获取长度 清空 销毁
2.链表

sqlist.h
#pragma once //防止头文件重复

//函数的声明以及结构体定义

//顺序表 定长顺序表 10

typedef struct SQlist
{
	int data[10];
	int length;
}SQList, * PSQlist;
//增删改查
void Init_SQlist(PSQlist ps);//初始化

bool Insert(PSQlist ps, int pos, int val);//按照位置插入

bool Del_pos(PSQlist ps, int pos);//按位置删除元素

bool Del_val(PSQlist ps, int val);//按值删除元素

bool IsEmpty(PSQlist ps);//判空

bool IsFull(PSQlist ps);//判满

int Get_Length(PSQlist ps);//获取有效元素

void Clear(PSQlist ps);//清空

void Destroy(PSQlist ps);//销毁

void Show(PSQlist ps);//实现

sqlist.cpp
#include<stdio.h>
#include<assert.h>
#include"sqlist.h"



void Init_SQlist(PSQlist ps)//初始化
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	//ps->data 数据域不需要初始化
	ps->length = 0;
}

bool Insert(PSQlist ps, int pos, int val)//按照位置插入
{
	assert(ps != NULL && 0 <= pos && pos <= ps->length);
	if (ps == NULL || pos < 0 && pos > ps->length)
	{
		return false;
	}
	if (IsFull(ps))
	{
		return false;
	}
	//挪动数据，将插入位置空出来
	for (int i = ps->length - 1; i >= pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	//把数值插入
	ps->data[pos] = val;
	ps->length++;
	return true;
}

bool Del_pos(PSQlist ps, int pos)//按位置删除元素
{
	assert(ps != NULL && pos >= 0 && pos < ps->length);
	if (ps == NULL || pos < 0 || pos >= ps->length)
	{
		return false;
	}
	//保证删除的顺序表存在，并且删除位置合法，且顺序表不为空
	if (IsEmpty(ps))
	{
		return false;
	}
	//将数据覆盖
	for (int i = pos + 1; i < ps->length; i++)
	{
		ps->data[i-1]=ps->data[i];
	}
	ps->length--;
	return true;
}

bool Del_val(PSQlist ps, int val)//按值删除元素
{
	assert(ps != NULL);
	//顺序表存在且不为空
	if (ps == NULL)
	{
		return false;
	}
	if (IsEmpty(ps))
	{
		return false;
	}
	//遍历，判断要删除的val值是否存在
	int tmp = 0;
	for (int i = 0; i < ps->length; i++)
	{
		if (ps->data[i] == val)
		{
			tmp = i;
			break;
		}
	}
	if (tmp == -1)
	{
		return false;
	}
	//调用上边函数按照位置删除
	Del_pos(ps, tmp);

	return true;
}

bool IsEmpty(PSQlist ps)//判空
{
	return ps->length == 0;
}

bool IsFull(PSQlist ps)//判满
{
	return ps->length == 10;
}
int Get_Length(PSQlist ps)//获取有效元素
{
	return ps->length;
}

void Clear(PSQlist ps)//清空
{
	ps->length = 0;
}

void Destroy(PSQlist ps)//销毁
{
	Clear(ps);
}
void Show(PSQlist ps)//实现
{
	assert(ps != NULL);

	for (int i = 0; i < ps->length; i++)
	{
		printf("%d", ps->data[i]);
	}
	printf("\n");

}

main.cpp
//实现定长顺序表
#include<stdio.h>
#include"sqlist.h"

int main()
{
	SQList sq;
	Init_SQlist(&sq);


	for (int i = 0; i < 5; i++)
	{
		Insert(&sq, i, i + 1);
	}
	Show(&sq);
	printf("length=%d \n", Get_Length(&sq));

	Del_pos(&sq, 2);
	Show(&sq);

	Del_val(&sq, 4);
	Show(&sq);

	printf("length=%d \n", Get_Length(&sq));

	Clear(&sq);
	Destroy(&sq);
	printf("length=%d \n", Get_Length(&sq));

	return 0;
}