数组 链表 栈 队列-笔记/总结

数组：

Array类：

只要类中有一个数据成员为指针时，拥有共性，1. 析构函数 2. 重载运算符 3. 复制构造函数

栈：

#include <stdafx.h>
#include <stdio.h>
#include <iostream>
#include <stack>
using namespace std;
int main()
{
stack<int> st;
/*
对栈的操作无非就是：验证是否为空、返回栈中元素数目、对栈顶元素删除、获取以及压入新元素
st.empty();    验证是否为空
st.size();    栈中元素个数
st.pop();        删除栈顶元素，无返回值
st.push();    将新元素压入栈中
st.top();        返回栈顶元素

st.size()为st对象调用stack类size函数
st->size()针对于指针对象指向size函数
*/
if(st.empty()){
cout<<"stack is empty"<<endl;
cout<<"刚进行初始化stack的大小:  "<<st.size()<<endl;                //输出size
st.push(111);
st.push(222);                        //压入栈顶,必须是同类型的int值
cout<<"push后的stack大小:  "<<st.size()<<endl;
cout<<"取出stack顶元素:  "<<st.top()<<endl<<endl;
//取出stack中所有元素
while(st.size()>0){
cout<<st.top()<<endl;
st.pop();
//因声明的是stack静态对象st，不用考虑内存泄漏
}
cout<<"stack size : "<<st.size()<<endl;
}
getchar();　　　　　　　　　　//程序暂停等待用户输入任意字符,让命令行窗口不会一闪而过
return 0;
}

链表：

　　单链表，双向链表，循环链表。。。。续

linklist *p;
p  = (linklist *)p->front;
p ->next == p -> rear;

队列：

#include <stdafx.h>
#include <stdio.h>
#include <iostream>
#include <queue>
using namespace std;
int main(){
queue<int> p;
/*
q.empty()               如果队列为空
q.size()                返回队列中元素的个数
q.pop()                 删除队列首元素无返回值
q.front()               返回队首元素的值，但不删除该元素
q.push()                在队尾压入新元素
q.back()                返回队列尾元素的值，但不删除该元素
*/
if(p.empty()){
cout<<"pop is empty"<<endl;
cout<<"刚进行初始化pop的大小:  "<<p.size()<<endl;                //输出size
p.push(111);
p.push(222);                        //压入栈顶,必须是同类型的int值
cout<<"push后的pop大小:  "<<p.size()<<endl;
cout<<"取出pop顶元素:  "<<p.front()<<endl<<endl;
//取出pop中所有元素
while(p.size()>0){
cout<<p.front()<<endl;
p.pop();
//因声明的是pop静态对象p，不用考虑内存泄漏
}
cout<<"pop size : "<<p.size()<<endl;
}
getchar();
return 0;
}

栈的数组实现 (利用栈的基本操作来实现对数组的操作)　　栈：后进先出　　数组：按 (索引->值) 依次存储

#include <stdafx.h>
#include <stdio.h>
#include <malloc.h>
#define maxsize 10
typedef struct        //定义结构体，并且在
{
int data[maxsize];    //数组大小
int top;            //栈顶坐标
int base;        //栈底坐标
}seqstack;            //seqstack为结构体的别名而已，还可以使用多个别名,且多个别名创建的对象使用的不是同一个内存空间, 并根据数组的结构定义成员
seqstack * s;            //栈
void initstack(seqstack * s)
{
s->top = 0;
s->base = 0;
}
int empty(seqstack * s)
{
if(s->top == s->base)
return 1;
else
return 0;
}
//入栈：赋值 , 索引++
void  push(seqstack * s, int x)
{
if(s->top >= maxsize-1)
{
printf("ERROR!\n");
}
else
{
s->data[s->top] = x;
s->top++;
}
}
//获取栈顶元素data[s->top--]  这里需要top--是因为入栈时top索引++了
void  pop(seqstack * s)
{
if(empty(s))
{
printf("ERROR!\n");
}
else
{
s->top--;
printf("%d\n",s->data[s->top]);
}
}
int main()
{
seqstack * s;
//（seqstack *）强转，malloc(size)申请大小为size动态内存空间，sizeof(seqstack)，seqstack类型占多少字节sizeof的值就是多大，如：sizeof(int) = 4
s = (seqstack *)malloc(sizeof(seqstack));
//此时s为空，s为指针对象，会以传址的方式将s传递给initstack函数
initstack(s);
push(s,1);
push(s,3);
pop(s);
push(s,2);
pop(s);
pop(s);
pop(s);
return 0;
}

栈的链表实现 (利用栈的基本操作来实现对链表的操作)

#include <stdafx.h>
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct node
{
int data;
struct node *next;
}node,linkstack;                    //使用多个别名,在这里node为节点
//初始化
void InitStack(linkstack * top)
{
top->next = NULL;
}
//是否为空   只用想想链表的结构就很清楚了，节点与节点之间通过指针关联，只要top->next为NULL即可
int IsEmpty(linkstack * top)
{
if(top->next == NULL) return 1;
return 0;
}
//入栈：新建一个节点赋值，让新节点的next指针指向NUll,栈内top->next指向新节点即可
int Push(linkstack * top, int x)
{
node * p;
p = (node *)malloc(sizeof(node));
if(p == NULL) return 0;
p->data = x;
p->next = top->next;            //top->next = null
top->next = p;
return 1;
}
//删除栈顶元素：
int Pop(linkstack * top, int *x)
{
node * p;
if(IsEmpty(top))
{
printf("ERROE!\n");
return 0;
}
p = top->next;
*x = p->data;
top->next = p->next;
free(p);
return 1;
}
int main()
{
int x;
linkstack * s;
s = (linkstack *)malloc(sizeof(linkstack));
InitStack(s);
Push(s,1);
Push(s,3);
Pop(s,&x);
printf("%d\n",x);
Push(s,2);
Pop(s,&x);
printf("%d\n",x);
Pop(s,&x);
printf("%d\n",x);
Pop(s,&x);
return 0;
}

队列的数组实现(利用数组的数据结构来对队列进行操作)　　　先想想数组的实现原理

原理：

front -> rear (假设队列顺序从左往右)

data[front] -> data[rear] (如果对队列中front、rear操作，则相应的数据元素、大小也随之变化)

#include <stdafx.h>
#include <stdio.h>
#include <malloc.h>
#define maxsize 66　　　　//定义变量
typedef struct　　　　　　//type define 结构定义
{
int data[maxsize];
int front,rear;　　　//front来记录列首,rear来记录列尾
}sequeue;
sequeue *q;　　　　　　　　　　//循环链表
void initqueue(sequeue *q)
{
q->front = -1;　　　　　　//q指针指向sequeue对象中的front方法
q->rear = -1;
}
int del(sequeue *q)　　　　　
{
if(q->front == q->rear)　　　　　　//列首列尾元素是否相等，若相等则是空的循环队列和数组
return NULL;
else
{
q->front++;　　　　　　　　　　//->优先级比++大，故先执行->然后++
return q->data[q->front];　　//实现对数组的删除操作,没调用此方法一次就让front记录的值+1　　
}
}
int insertqueue(sequeue *q,int x)　　　　//向队列中插入元素，思路：先判断列尾是否超出maxsize大小，然后让索引rear+1，对应的给数组data[rear+1]赋值,来实现插入
{
if(q->rear >= maxsize-1)
return NULL;
else
{
(q->rear)++;　　　　　　　　　　　　//列尾+1
q->data[q->rear] = x;
return 1;
}
}
int empty(sequeue * q)　　　　　　　　　　//简单判断队列是否为空，也就是数组data是否为空
{
if(q->front == q->rear)
return 0;
else
return 1;　　　　　　　　　　　　　//这里也可扩展，返回队列元素大小,前提是需要让rear递增
}
void print(sequeue * q)　　　　　　　　　　//遍历输出数据元素
{
if(q->front == q->rear)
printf("ERROR!\n");
else
{
while(empty(q))
{
q->front++;
printf("%d\n",q->data[q->front]);
}
}
}
int main()
{
int i;
sequeue *q;
q  = (sequeue *)malloc(sizeof(sequeue));
initqueue(q);
for(i = 0; i < 6; i++)
insertqueue(q,i);
printf("front is %d\n\n",del(q));
printf("Then the last data is:\n");
print(q);
return 0;
}

队列的链表实现 (利用链表的数据结构来实现对队列的操作)　　先想想链表的实现原理，要知道链表中某个节点，那就必须要知道它上一个节点

节点： [值 | 指针] (指向下一个节点的内存地址)

front -> rear (假设队列顺序从左往右)

#include <stdafx.h>
#include <stdio.h>
#include <malloc.h>
typedef struct node　　　　　　　　//节点
{
int data;　　　　　　　　　　　　//值
struct node * next;　　　　　　//指针
}linklist;　　　　　　　　　　　　　//节点对象　　　　　　　　　　　　　
typedef struct
{
linklist * front, * rear;　　//定义结构对象的两个指针，front表示上一个节点，rear表示下一个节点
}linkqueue;　　　　　　　　　　　　　　
linkqueue * q;　　　　　　　　　　　//链表　　　　　　　　　
//建立队列
void initqueue(linkqueue * q)
{
q->front = (linkqueue *)malloc(sizeof(linklist));　　//动态分配,初始化为0
q->front->next = NULL;　　　　　　　　　　　　　　　　　　//将首节点中指向下一节点的指针置空
q->rear = q->front;　　　　　　　　　　　　　　　　　　　　//队列首位
}
//判断队列空否
int empty(linkqueue * q)
{
if(q->front == q->rear)
return 1;
else
return 0;
}
//入队列     先定义一个与listlink相同的节点对象，然后再将它加入链表队列中(rear->next指向新建的节点)
void inqueue(linkqueue * q, int x)
{
q->rear->next = (linklist *)malloc(sizeof(linklist));　　　　//q->rear->next本来是NULL的，现在将对它赋予节点对象，也就连接了rear和rear->next
q->rear->next->data = x;　　　　　　　　　　　　　　　　　　　　
q->rear = q->rear->next;　　　　　　　　　　　　　　　　　　　　//让rear没有下一个节点
q->rear->next = NULL;　　　　　　　　　　　　　　　　　　　　　　　//确定操作的rear节点位于链尾
}
//出队列    从front节点开始一节一节的取,此方法每调用一个就取一个,一直取到最后一个时,就会一直返回q->rear
int outqueue(linkqueue * q)
{
linklist * s;
if(empty(q))
return NULL;
else
{
s = q->front->next;
printf("%d\n",s->data);
if(s == q->rear)
q->front = q->rear;
else
q->front->next = s->next;
free(s);
return 1;
}
}
//main
int main()
{
int i;
linkqueue * l;
l = (linkqueue *)malloc(sizeof(linkqueue));
initqueue(l);
for(i = 0; i < 10; i++)
inqueue(l,i);
for(i = 0; i < 10; i++)
outqueue(l);

return 0;
}