一、数据结构
程序设计=算法+数据结构+设计模式
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<iostream>
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<iostream>
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<iostream>
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<iostream>
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<iostream>
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;
}