数据结构和算法
一、数据结构
程序设计=算法+数据结构+设计模式
1.集合：简单的包装容器，数据元素没有特定的耦合性。
2.线性结构：一对一的关系。
int a[10] = {0, 1, 2, ...};
a[0] -> 0
a[3] -> 4
下标<->元素
3.树形结构：一对多的关系。
4.图状结构（网状结构）：多对多的关系。
二、数据结构的存储方式
1.顺序方式：用元素的相对位置表示其逻辑关系。
a[3] <==> *(a+3)
2.链式方式：在每个元素存放另一个元素的索引。
三、逻辑结构和物理结构
线性表（数组、链表）-顺序、链式
树-顺序、链式
图-链式
四、常用数据结构
1.线性结构(一维)
1)一般线性表
2)受限线性表：堆栈、队列、串
3)推广线性表：数组、广义表
2.非线性结构（二维）
1)集合
2)树形结构：二叉树、一般树
3)图形结构：有向图，无向图
五、数据结构的运算
1.构建
2.销毁
3.插入
4.删除
5.针对特定元素的访问
6.遍历，每个元素被访问一次，不重不漏
7.排序
8.查找
六、线性表的两种存储方式
1.顺序：内存连续，随机访问方便，插入删除效率低，空间要求高。
2.链式：内存不连续，插入删除效率高，空间要求低，随机访问不方便。
七、堆栈
后进先出
push/pop
顺序表/链表，空间初始化，栈顶位置，判满判空
1234(8)
1*8^3 + 2*8^2 + 3*8^1 + 4*8^0
八、队列
先进先出(FIFO)
push/pop
顺序表/链表，空间初始化，从后端入队，从前端出队，循环使用，判满判空
csd1301/tam_0125
eg: stack.cpp //顺序表式堆栈、
#include
using namespace std;
class Stack{ //堆栈类
public:
//构造函数
Stack(){}
//析构函数
~Stack(){}
//压入数据用push()
void push (int data){}
//弹出数据用pop()
void pop (int data){}
//判空empty()
bool empty(void){}
pravate:
class OverFlow:public exception{};//抛出异常类，
class UnderFlow:public exception{};
int* m_data; //数据指针
size_t m_size; //堆栈的容量大小
size_t m_top;//堆栈的栈顶
};
int main(void){
try{}
catch(){}
return 0;
}
eg: lstack.cpp //链表式的堆栈；
#inclide
using namespace std;
class Stack{
public:
Stack(){}
~Stack(){}
//压入数据
void push(int data){}
//弹出数据
int pop(void){}
//判空
bool empty(){}
private:
//堆栈下益（异常处理）
class UnderFlow：public exception{};
//节点类
class Node{};
Node* m_top;
};
int main(){
try{}
catch{}
return 0;
}
eg: queue.cpp //(顺序表式队列)
#include
using namespace std;
class queue{
public:
//构造函数初始化分配内存
queue(size_t size = 5):m_data(new int[size]),m_size(size),m_rear(0),m_front(0),m_count(0){}
//析构函数释放内存空间
~queue(void){
if(m_data){
delete[] m_data;
m_data = NULL;
}
}
//压入数据
void push(int data){}
//弹出数据
int pop(void){}
bool empty(void){}
private:
class OverFlow: public exception{
const char* what(void) const throw(){return "队列上溢";}
};//上溢异常
class UnderFlow: public exception{
const char* what(void) const throw(){return "队列下益"}
};//下益异常
int* m_data; //数组
size_t size; //容量
size_t m_rear; //后端（压入）
size_t m_front; //前端（弹出）
size_t m_count; //计数
};
int main(void){
try{}
catch(){}
return 0;
}
eg: lqueue.cpp //链表式队列
#include
using namespace std;
class Queue{
public:
//构造函数
Queue{};
//析构函数
~Queue{};
//压入
void push(int data){}
//弹出
int pop(void){}
//判空
bool empty(){}
private:
//异常处理类
class UnderFlow: public exception{};
//结点类
class Node{};
Node* m_front； //前端
Node* m_rear； //后端
};
int main(void){
try{} //关键字try检测异常代码块的
catch{} //关键字catch用来填写异常代码
return 0;
}
eg: list.cpp 链表
#include
using namespace std;
class List{
public:
//构造
List(){}
//析构释放剩余结点
~List(){}
//追加
void append(int data){}
//插入
void insert(int data){}
//删除/移除
void remove(size_t index){}
//正遍历
void forward(void){}
//反遍历
void backward(void){}
//伪随机访问
int& operator[] (size_t index){}
//获取元素数量
size_t size(void) const{}
private:
//链表越界
class OverBound:public exception{};
//结点类
class Node{
public：
Node(){}
int m_data;
Node* m_prev; //前指针
Node* m_next； //后指针
};
Node* m_head;
Node* m_tail;
};
int main(void){
try{}
catch{}
return 0;
}