数据结构和算法

第一课  堆栈和队列
一、数据结构
程序设计=算法+数据结构+设计模式
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;

}