1-1概览
二叉树 二叉平衡树
顺序表
链表
哈希表
结构：
物理结构：顺序结构 链式结构
逻辑结构：集合，线性表，树状，图形
数据：各种数据，可以输入和计算机处理
2-1时间复杂度和空间复杂度
穷举法O（n）
a&2 = a%2 a模2的余数
递归枚举：深度优先搜索
大O记法：和次数有关 高阶无穷小
常数 对数（二分查找） 根号阶 线性阶
a log n n
二分查找
int binary(int n, int*p, int value){
int l = 0, r = n - 1;
while (l <= r) {
int mid = (l + r) >> 1;//右移，二进制
if (p[mid] == value) return mid;
else if (p[mid] < value) r = mid + 1;
else l = mid + 1; //if (p[mid] > value)
}
return -1;
}线性对数阶 多项式阶 指数阶 阶乘阶 （暴力算法）
标准 与 s = 10^6
n<12 n!
n<16 2n n2n
n<30 n4
n<100 n3
n<1000 n^2
n<100000 nlog 2 n
n<10^6
空间复杂度：
顺序表 n 树：n为结点的数量
链表 ：n 图：O（m+n）n为顶点，m为边
栈： n是栈的最大深度
队列：n是队列的最大长度
哈希表：表中元素的数量
4-1顺序表
1.顺序表的插入
将元素插入索引位置，后面元素向后移
步骤：1检查合法性2顺序表满需要扩容倍增3后移元素4插入元素5给出新的顺序表大小
2.顺序表的删除
将给定索引的元素删除，元素前移
步骤：1检查合法性抛出异常2最后一个元素，索引减一3删除目标索引，前移元素4更新顺序表
3.顺序表的查找
挨个查找，找到则返回索引，否则-1，时间复杂度O（n）
步骤：遍历顺序表，相等则返回索引，没找到返回-1
4.顺序表的修改
将指定位置的元素进行更新
5.顺序表的索引
元素的下标为索引，使用索引直接获取，时间复杂度为O1
使用c++实现顺序表
#include<iostream>
using namespace std;
#define eleType int
struct SequentialList{
eleType* elements;
int size;
int capacity;
};
void initializeList(SequentialList *list , int capacity){
list->elements = new eleType[capacity];
list->size = 0;
list->capacity = capacity;
}
void destroyList(SequentialList* list){
delete[] list->elements;
}
int sizeSequentialList(SequentialList* list){
return list->size;
}
bool isEmpty(SequentialList* list){
return list->size == 0;
}
void insert(SequentialList* list, int index, eleType value){
if (index < 0 || index > list->size){//可以在最后一个位置插入
throw std::invalid_argument("invalid index");
}
if (list->size == list->capacity){
int newCapacity = list->capacity * 2;
eleType* newElements = new eleType[newCapacity];
for (int i = 0; i < newCapacity; ++i) {
newElements[i] = list->elements[i];
}
delete[] list->elements;
list->elements = newElements;
list->capacity = newCapacity;
}
for (int i = list->size; i > index; --i){
list->elements[i] = list->elements[i - 1];
}
list->elements[index] = value;
list->size++;
}
void deleteElements(SequentialList* list,int index){
if (index < 0 || index >= list->size){//下标从0开始
throw std::invalid_argument("invalid index");
}
for (int i = index; i < list->size; i++) {
list->elements[i] = list->elements[i + 1];
}
list->size--;
}
int findElements(SequentialList* list, eleType element) {
for (int i = 0; i < list->size; i++) {
if (list->elements[i] == element)
return i;
}
return -1;
}
eleType getElement(SequentialList* list, int index) {
return list->elements[index];
}
void updateElement(SequentialList* list, int index,eleType value) {
list->elements[index] = value;
}
int main() {
SequentialList mylist;
initializeList(&mylist, 10);
for (int i = 0; i < 10; i++) {
insert(&mylist, i, i * 10);
}
for (int i = 0; i < 10; i++) {
cout << getElement(&mylist, i) << endl ;
}
return 0;
}
c++中的模板类的使用ＳＴＬ
vector
#include<iostream>
#include<vector>
using namespace std;
int main() {
vector<int> ret = { 1,2,3,4,5 };
for (int i = 0; i < ret.size(); i++) {
cout << ret[i] << ' ';
}
ret.push_back(1024);
cout << ret[5] << endl;
cout << ret.size() << endl;
}求二进制数的最大连续一
#include<iostream>
#include<vector>
using namespace std;
int main() {
vector<int> a= { 1,1,0,1,1 };
int ret = 0, pre = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == 1) pre += 1;
else if (pre > ret) ret = pre;
}
cout << ret;
return 0;
}5-1链表
链表的实现
增删改查
题目
#include<iostream>
#include<stdexcept>
using namespace std;
#define eleType int
struct ListNode {
eleType date;
ListNode* next;
ListNode(eleType x):date(x), next(NULL) {}
};
class LinkedNode {
private:
int size;
ListNode* head;
public:
LinkedNode():head(NULL),size(0){}
~LinkedNode();
void insert(eleType value, int i);
void remove(int i);
ListNode* findList(eleType value);
ListNode* getvalue(int i);
void update(int i, eleType value);
void print();
};
LinkedNode::~LinkedNode() {
ListNode* pre = head;
ListNode* p = head->next;
while (p) {
delete pre;
pre = p;
p = p->next;
}
}
void LinkedNode::insert(eleType value, int i) {
if (i < 0 || i>size) {
throw std::out_of_range("invalid position");
}
ListNode* NewList = new ListNode(value);
if (i == 0) {
NewList->next = head;
head = NewList;
}
else {
ListNode* p = head;
for (int j = 0; j < i - 1; j++) {
p = p->next;
}
NewList->next = p->next;
p->next = NewList;
}
size++;
}
void LinkedNode::remove(int i) {
if (i < 0 || i>size) {
throw std::out_of_range("invalid position");
}
if (i == 0) {
ListNode* tem = head;
head = head->next;
delete tem;
}
else {
ListNode* p = head;
for (int j = 0; j < i - 1;j++) {
p = p->next;
}
ListNode* tem = p->next;
p->next = tem->next;
delete tem;
}
size--;
}
ListNode* LinkedNode::findList(eleType value) {
ListNode* p = head;
while(p && p->date !=value){
p = p->next;
}
return p;
}
ListNode* LinkedNode::getvalue(int i) {
if (i < 0 || i>size) {
throw std::out_of_range("invalid position");
}
ListNode* p = head;
for (int j = 0; j < i ; j++) {
p = p->next;
}
return p;
}
void LinkedNode::update(int i, eleType value) {
getvalue(i)->date = value;
}
void LinkedNode::print() {
ListNode* p = head;
while(p) {
cout << p->date << endl;
p = p->next;
}
}
int main() {
LinkedNode s;
s.insert(10, 0);
s.print();
return 0;
}快慢指针
#include<iostream>
using namespace std;
//加上链表的代码
int main() {
int* fast, * slow;
fast = head;
while (k--) {
fast = fast->next;
}
while (fast) {
fast = fast->next;
slow = slow->next;
}
value = slow->val;
return 0;
}二进制转十进制
#include<iostream>
using namespace std;
int main() {
int a[10] = { 1,0,1 };
int sum = 0;
for (int i = 0; i < 3; i++) {
sum = sum * 2 + a[i];
}
cout << sum;
return 0;
}6-1 栈
概念：栈是一种数据结构，遵循后进先出的规则，函数递归，表达式求值，函数调用等，可以用顺序表或者链表实现。
出栈：也可以叫弹栈，将栈顶元素删除。将栈顶指针指向新的元素。
入栈：也可以叫压栈，进栈，将元素添加到栈顶。
步骤：将元素压入栈顶，将栈顶指针指向新元素。 增加栈的大小。
栈实现的代码（顺序表实现）
#include<iostream>
#include<stdexcept>
using namespace std;
template<typename T>
class Strack {
private:
T* data;
int capacity;
void resize();
public:
Strack():data (new T[capacity]),size(0),capacity(10){}
~Strack();
void push(T element);
T pop();
T top() const;
int getSize() const;
};
template<typename T>
void Strack<T>::resize() {
int newCapacity = capacity * 2;
T* newDate = new T[newCapacity];
for (int i = 0; i < capacity; i++) {
newDate[i] = Data[i];
}
delete[] data;
data = newData;
capacity = newCapacity;
}
template<typename T>
Strack<T>::~Strack() {
delete data;
}
template<typename T>
void Strack<T>::push(T element) {
if (size == capacity) {
resize();
}
data[size++] = element;
}
template<typename T>
T Strack<T>::pop() {
if (size == 0) {
throw std::underflow_error("strack is empty");
}
return data[size--];
}
template<typename T>
T Strack<T>::top() const{
if (size == 0) {
throw std::underflow_error("strack is empty");
}
return data[size - 1];
}
template<typename T>
int Strack<T>::getSize ()const{
return size;
}c++中的模板类
#include<iostream>
#include<stack>
int main(){
stack<int> intStk;
stack<double> doubleStk;
return 0;
}
//empty()
//pop()
//push()
//top()7-1 队列
概念：队列是一种先进先出的数据结构，和我们生活中排队类似，队列仅限在队尾插入，表头删除的结构，可以实现排队系统，任务调度，消息传递。
入队：将数据从队尾插入，可以使用链表和顺序表实现。更新队尾指针，或顺序表的索引
查找：返回队首指针。
#include<iostream>
#include<stdexcept>
using namespace std;
template<typename T>
class queue {
private:
int front;
int rear;
T* data;
int capacity;
void resize();
public:
queue() : data(new T[capacity]), front(0),rear(0),capacity(10){}
~queue();
void enQueue(T element);
T deQueue();
T getFront() const;
int getSize() const;
};
template<typename T>
void queue<T>::resize() {
T* newdata = new T[capacity * 2];
for (int i = 0; i < capacity; i++) {
newdata[i] = data[i];
}
delete[] data;
data = newdata;
capacity *= 2;
}
template<typename T>
queue<T>::~queue() {
delete[] data;
}
template<typename T>
void queue<T>::enQueue(T element){// 入队
if (rear == capacity) {
resize();
}
data[rear++] = element;
}
template<typename T>
T queue<T>::deQueue() {//出队
if (front == rear) {
throw std::underflow_error("queue is empty");
}
return data[front++];
}
template<typename T>
T queue<T>::getFront() const {//获取队头元素
if (front == rear) {
throw std::underflow_error("queue is empty");
}
return data[front];
}
template<typename T>
int queue<T>::getSize() const {//获取元素数量
return rear - front;
}
int main() {
return 0;
}使用链表实现
#include<iostream>
#include<stdexcept>
using namespace std;
template<typename T>
class queue {
private:
struct Node {
T data;
Node* next;
Node(T d) : data(d),next(NULL){}
};
Node* front;
Node* rear;
int size;
public:
queue() : front(NULL),rear(NULL),size(0){}
~queue();
void enQueue(T element);
T deQueue();
T getFront() const;
int getSize() const;
};
template<typename T>
queue<T>::~queue() {
while ( front ) {
Node* temp = front;
front = front->next;
delete front;
}
}
template<typename T>
void queue<T>::enQueue(T element){// 入队
if ( rear == NULL) {
rear = new Node(element);
front = rear;
}
else {
rear->next = new Node(element);
rear = rear->next;
}
size++;
}
template<typename T>
T queue<T>::deQueue() {//出队
if (front == NULL) {
throw std::underflow_error("queue is empty");
}
T element = front->data;
Node* temp = front;
front = front->next;
delete temp;
size--;
return element;
}
template<typename T>
T queue<T>::getFront() const {//获取队头元素
if (front == NULL) {
throw std::underflow_error("queue is empty");
}
return front->data;
}
template<typename T>
int queue<T>::getSize() const {//获取元素数量
return size;
}
int main() {
queue<int> q;
q.enQueue(10);
cout << q.getFront() << endl;
q.enQueue(20);
cout << q.getSize() << endl;
while (q.getSize()) {
cout << q.getFront() << endl;
q.deQueue();
}
return 0;
}queue的基本用法
#include <iostream>
#include<queue>
using namespace std;
int main()
{
queue<int> q;
q.push(0);
q.push(1);
q.push(2);
while(!q.empty()){
cout<<q.front()<<endl;
q.pop();
}
return 0;
}8-1串
串就说字符串，在c++中串以\0结尾。
获取字符串的长度，串的索引，串的拷贝，比较。
#include <iostream>
#include<cstring>
using namespace std;
class String {
private:
rsize_t length;
char* str;
public:
String();
String(const char* s);
~String();
String(const String& s);
size_t GetLength() const;
char operator [] (size_t index) const;
String& operator =(const String& s);
bool operator == (const String& s);
bool operator != (const String& s);
String copy() const;
String operator +(const String& s) const;
friend ostream& operator << (ostream& out, const String& s);
};
String::String() {
length = 0;
str = new char[1];
str[0] = '\0';
}
String::String(const char* s) {
length = strlen(s);
str = new char[length + 1];
strcpy(str, s);
}
String::~String() {
delete[] str;
}
String::String(const String& s) {
length = s.length;
str = new char[length + 1];
strcpy(str, s.str);
}
size_t String::GetLength() const {
return length;
}
char String::operator [] (size_t index) const {
return str[index];
}
String& String::operator =(const String& s) {
if (*this != s) {
delete[] str;
length = s.length;
str = new char[length + 1];
strcpy(str, s.str);
}
return *this;
}
bool String::operator == (const String& s) {
return strcmp(str, s.str) == 0;
}
bool String::operator != (const String& s) {
return strcmp(str, s.str) != 0;
}
String String::copy() const {
String s = *this;
return s;
}
String String::operator +(const String& s) const {
String result;
result.length = length + s.length;
result.str = new char[result.length];
strcpy(result.str, str);
strcat(result.str, s.str);
return result;
}
ostream& operator << (ostream& out, const String& s) {
out << s.str;
}9-1树
树是n个结点有限集合。当 n = 0时，为空树。
n > 0 时，满足两个条件。
（1）有且仅有一个结点称为root结点。
（2）当n>1时，其余结点分为m个互不相交的有限集合，每一个Ti又是一个树，称为root的子树。
子树没有限制，他们一定互不相交，但是不能形成环。
树的结点包括m个指针域和一个数据域，指针域用来指向它的子树，结点的分类为：根节点，叶子结点，内部结点。结点拥有子树的个数，被称为结点的度，树中各个结点度的最大值，被称为树的度。
（1）根节点
一棵树的根节点只有一个。
（2）叶子结点
度为0的结点被称为叶子结点，叶子结点不能指向任何树，
（3）内部结点
除了根节点和叶子结点的其他结点都叫内部节点。
孩子结点：对于某个结点，他的子树的根节点被称为该节点的孩子结点。
d是b的孩子结点。a是b父结点。c是b的兄弟结点。
最大层次为树的深度。
森林的定义
森林是m棵互不相交的树的集合，对于树的每个结点而言，其子树集合就是森林，如图所示，b和c两颗子树组成的集合就是一个森林。
结点id，root结点id为0；从上至下，从左至右。
结点池：给出一个n个节点的树，这个n是有上限的，将结点事先存储在一个顺序表中。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
