实验三 队列实现杨辉三角

第一篇：实验三 队列实现杨辉三角

实验3队列实现杨辉三角

一、实验目的

1.熟悉队列的逻辑结构。2.回顾常用的存储结构。

3.掌握System.Collection.Queue类的使用方法。

4.熟悉队列的几种典型应用，用队列来解决一些编程问题。5.用循环队列实现杨辉三角并测试。

二、实验内容

杨辉三角是除了每一行的第一个元素和最后一个元素是1，其他元素的值是上一行与之相邻的两个元素之和。

1.实现循环队列类 a)两个构造函数 b)入队 c)出队

2.用顺序循环队列实现杨辉三角(一)程序分析 2.1存储结构

用一片连续的存储空间来存储循环队列中的数据元素，即采用顺序存储的方式。2.2 关键算法分析 1.出队

1)自然语言描述： a.判断队列是否空 b.如果队列空，抛出异常 c.如果队列不空，则

i.ii.iii.元素出队 移动对头指针 队列长度减1 代码描述：

publicvirtualobjectDequeue()//出队 {

} if(this._size == 0){ //队下溢

} object obj2 = this._array[this._head];//出队 this._array[this._head] = null;//删除出队元素 //移动队头指针

this._head =(this._head + 1)% this._array.Length;this._size--;return obj2;thrownewInvalidOperationException(“队列为空”);时间复杂度：O(1)2.入队

自然语言描述：

d.判断队列是否满 e.如果队列满，则扩容 f.如果队列不满，则

a)元素入队 b)移动队尾指针 c)队列长度加1 代码描述:

publicvirtualvoidEnqueue(objectobj)//入队 {

} if(this._size == this._array.Length)//当数组满员时 { //计算新容量

} this._array[this._tail] = obj;//入队

this._tail =(this._tail + 1)% this._array.Length;//移动队尾指针 this._size++;int capacity =(int)((this._array.Length * this._growFactor)/ 100L);if(capacity <(this._array.Length + _MinimumGrow)){ //最少要增长4个元素

} this.SetCapacity(capacity);//调整容量 capacity = this._array.Length + _MinimumGrow;时间复杂度：O(1)3.打印杨辉三角

自然语言描述： 要定义的变量：

1)行：n

2)列：

i.ii.空格 j 数值

k 3)左肩：left 4)右肩：right 代码描述:

三、程序运行结果

四、实验心得

1.调试时出现的问题及解决的方法

2.心得体会

3.下一步的改进

第二篇：实验三 栈和队列

实验报告三 栈和队列

班级： 姓名： 学号： 专业：

一、实验目的：

（1）掌握栈的基本操作的实现方法。

（2）利用栈先进后出的特点，解决一些实际问题。（3）掌握链式队列及循环队列的基本操作算法。（4）应用队列先进先出的特点，解决一些实际问题。

二、实验内容：

1、使用一个栈，将一个十进制转换成二进制。粘贴源程序：

package Word1;

public class Node {

} T data;Node next;public Node(T a){ } public Node(T a,Node n){

} this.data=a;this.next=n;this(a,null);

-----package Word1;

public class Stack {

} public Node Top;public Stack(){ } public void push(T a){ } public T Out(){

}

T a=this.Top.data;this.Top=this.Top.next;return a;this.Top=new Node(a,this.Top);this.Top=null;

--package Word1;

import java.util.*;

public class Test {

} static Scanner scan=new Scanner(System.in);static int temp=0;static int a=0;static Stack s=new Stack();public static void main(String[] args){

} temp=scan.nextInt();while(true){

} while(s.Top!=null){

} System.out.printf(“%d”,s.Out());a=temp%2;s.push(a);temp=temp/2;if(temp==0)break;

粘贴测试数据及运行结果：

2、回文是指正读反读均相同的字符序列，如“acdca”、“dceecd”均是回文，但“book”不是回文。利用1中的基本算法，试写一个算法判定给定的字符串是否为回文。（提示：将一半字符入栈，依次弹出与另一半逐个比较）粘贴源程序：---------package Word1;

import java.util.*;public class Test1 {

} static Scanner sc=new Scanner(System.in);static char[] c={'a','b','c','b','a'};static Stack s=new Stack();public static void main(String[] args){

} public static String One(){

} public static String Two(){

} for(int i=0;i<(c.length/2);i++){ } for(int i=c.length/2;i

} return “该字符串是回文”;if(s.Out()!=c[i])return “该字符不是回文”;s.push(c[i]);for(int i=0;i<(c.length/2);i++){ } for(int i=c.length/2+1;i

} return “该字符串是回文”;if(s.Out()!=c[i])return “该字符串不是回文”;s.push(c[i]);if(c.length%2!=0){

} else{ } System.out.println(Two());System.out.println(One());

-------------

粘贴测试数据及运行结果：

3、使用3个队列分别保留手机上最近10个“未接来电”、“已接来电”、“已拨电话”。

粘贴源程序：

package Word3;

import java.util.*;

public class Queue {

LinkedList list;public Queue(){ } public void enQ(E a){ } public E deQ(){ } public boolean isEmpty(){ } public void Pri(){ while((list.isEmpty()))return list.isEmpty();return list.removeLast();list.addLast(a);list=new LinkedList();

} } System.out.printf(“%d n”,this.deQ());

package Word3;

import java.util.*;

public class Test {

static Queue list1=new Queue();static Queue list2=new Queue();static Queue list3=new Queue();static Scanner sc=new Scanner(System.in);public static void main(String[] args){ } public static void Frame(){

} static private void T2(){

int c;int[] a={22324,321321,222333};for(int i=0;i

1、查询

2、增加”);c=sc.nextInt();if(c==1){

} else{ c=sc.nextInt();while(!(list2.isEmpty()))System.out.printf(“%d n”,list2.deQ());list2.enQ(a[i]);int c=0;System.out.println(“请选择记录类型：”);System.out.println(“

1、未接来电

2、已接来电

3、已拨电话”);switch(c=sc.nextInt()){

} case 1:T1();break;case 2:T2();break;case 3:T3();break;Frame();

}

} list2.enQ(c);while(!(list2.isEmpty()))System.out.printf(“%d n”,list2.deQ());sc.close();static private void T3(){

} static private void T1(){

int c;int[] a={12324,321321,222333};for(int i=0;i

1、查询

2、增加”);c=sc.nextInt();if(c==1){

} else{ c=sc.nextInt();while(!(list1.isEmpty()))System.out.printf(“%d n”,list1.deQ());list1.enQ(a[i]);int c;int[] a={32324,321321,222333};for(int i=0;i

1、查询

2、增加”);c=sc.nextInt();if(c==1){

} else{

} sc.close();c=sc.nextInt();list3.enQ(c);while(!(list3.isEmpty()))System.out.printf(“%d n”,list3.deQ());while(!(list3.isEmpty()))System.out.printf(“%d n”,list3.deQ());list3.enQ(a[i]);

}

}

} list1.enQ(c);while(!(list1.isEmpty()))System.out.printf(“%d n”,list1.deQ());sc.close();

粘贴测试数据及运行结果：

三、心得体会：（含上机中所遇问题的解决办法，所使用到的编程技巧、创新点及编程的心得）

第三篇：实验三 栈和队列的应用

一、实验目的 掌握栈的数据类型描述及栈的特点； 掌握栈的顺序存储结构的特点及算法描述； 掌握队列的数据类型描述及链式存储结构的特点和算法描述。

二、实验内容

停车场管理。设有一个可以停放n辆汽车的狭长停车场（先进后出），它只有一个大门可以供车辆进出。车辆按到达停车场时间的先后依次从停车场最里面向大95E8口处停放（最先到达的第一辆车停放在停车场的最里面）。如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车离开，则排在便道上的第一辆车就可以进入停车场。停车场内如有某辆车要离开，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车再按原来的次序进停车场。每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。如果停留在便道上的车没进停车场就要离开，允许其离开，不收停车费，并且仍然保持在便道上的车辆次序。试编程模拟停车场管理。

三、算法描述

提示：可以将停车场定义成一个顺序栈s1，便道定义成一个链队列q，而停车场中的某辆车要离开，则在它后面进停车场的车必须让道，让其离开，故还必须有一个临时的顺序栈s2，存放让道的车辆。

当有车辆进停车场时，直接进入s1栈，若s1栈满，则进入便道（链队列q）。若有s1中车辆x离开时，先让在x后面进栈的车从s1退栈并进栈到s2中，让x离开并收取停车费，然后，再把s2中的所有车辆退栈并重新进入s1栈，最后，将链队列q的队头车辆进栈到s1中并删除队头车辆。若有链队列q（便道）中的车辆y离开时，从链队列中删除该车辆即可，不收停车费。

车辆的数据可以表示为（车辆编号，到达/离开时间）。

四.程序清单: #include using namespace std;const int StackSize=5;class SeqStack { public:

SeqStack(){top=-1;} ~SeqStack(){};void Push(int x);void Push2(int x);int *Return();int Pop(int y);int Count();void PrintStack();private: int data[StackSize];int top;};//入栈

void SeqStack::Push(int x){ if(top>=StackSize-1)throw“上溢”;for(int i=0;i<=top+1;i++){

if(data[i]==x)

{

cout<<“该车牌已经存在!请重新输入: ”;

i=-1;

cin>>x;

} } top++;data[top]=x;} //返回数组地址

int *SeqStack::Return(){ return data;} //临时栈

void SeqStack::Push2(int x){ top++;data[top]=x;

} //输出函数

void SeqStack::PrintStack(){ for(int i=0;i<=top;i++)

cout<<“位置为”<

int SeqStack::Pop(int y){ if(top==-1)throw“下溢”;int x;x=data[top--];if(y==top+2)data[top+1]=123456789;if(top==-1)data[top+1]=123456789;return x;} //数数

int SeqStack::Count(){ return top;}

//队列

struct Node { int data;Node *next;};class LinkQueue { public: LinkQueue();void EnQueue(int x,int *q);void xzDeQueue(int x);int Count();int DeQueue();

private: Node *front,*rear;};//构造函数

LinkQueue::LinkQueue(){ Node *s=new Node;s->next=NULL;front=rear=s;} //入队

void LinkQueue::EnQueue(int x,int *q){ Node *s=new Node;Node *p=new Node;p=front;while(p){

if(p->data ==x)

{

cout<<“便道已有该车牌号,请重新输入: ”;

cin>>x;

for(int i=0;i<5;i++)

{

if(x==q[i])

{

cout<<“停车场已有该车牌号,请重新输入: ”;

cin>>x;

i=-1;

}

}

p=front;} p=p->next;} s->data =x;s->next =NULL;

rear->next =s;rear=s;} //出队

int LinkQueue::DeQueue(){ if(front==rear)throw“便道无车辆”;Node *p=new Node;int x;p=front->next;x=p->data;front->next =p->next;if(p->next ==NULL)rear=front;delete p;return x;} //计算结点数

int LinkQueue::Count(){ Node *p=new Node;p=front;int i=0;while(p&&p->next!=NULL){

p=p->next;

i++;} return i;} //选择性出队

void LinkQueue::xzDeQueue(int x){ if(rear==front)throw“便道无车辆”;Node *p=new Node;p=front;int y;int i=0;for(;p->next!=NULL;p=p->next)

{

if(p->next->data ==x)

if(p->next->next!=NULL)

{

Node *q=new Node;

q=p->next;

y=q->data;

p->next =q->next;

i=1;

delete q;

cout<<“车牌号为:”<

break;

}

else

{

Node *q=new Node;

q=p->next;

y=q->data;

p->next =NULL;

i=1;

delete q;

if(front->next==NULL)rear=front;

cout<<“车牌号为:”<

break;

}

} if(i==0)cout<<“无车牌号为:”<

SeqStack b;//b是作为临时存放车辆的栈

LinkQueue c;//c是作为便道的队列

cout<<“tttt1.车辆进入”<

cout<<“tttt4.便道车辆离开”<

int xh1=1;//xh1为菜单最外层的循环控制变量

int time[100];//记录各车辆进入停车场的时间

int t1=0;//作为车辆对应的时间编号

int money=1;while(xh1==1){

cout<<“请选择指令: ”;

cin>>zl;

switch(zl)

{

case 1:

try{

int n1=a.Count();

int n;

cout<<“请输入车牌号: ”;

cin>>n;

if(n1==4)

{

int *Num=a.Return();

for(int i=0;i<=4;i++)

if(Num[i]==n)

{

cout<<“停车场已有该车牌号,请重新输入!”;

cin>>n;

i=-1;

}

int *CarNum=a.Return();

c.EnQueue(n,CarNum);

cout<<“停车场已满,请在便道等候!”<

break;

}

a.Push(n);

cout<<“请输入进入时间: ”;

cin>>time[t1];

while(time[t1]<0||time[t1]>=24)

{

cout<<“请输入正确的时间(0~23时):”;

cin>>time[t1];

}

t1++;

}

catch(char*s){cout<

break;

case 2:

try{int n2;//离开车辆的编号

cout<<“请输入要离开的车的位置: ”;

cin>>n2;

if(a.Count()+1==0)

{

cout<<“该停车场没有车辆,请选择其他操作!”;

break;

}

else

while(n2<1||n2>a.Count()+1)

{

cout<<“请输入1~”<

cin>>n2;

}

int j=a.Count();

for(int i=0;i<(j+1-n2);i++)

b.Push2(a.Pop(n2));

a.Pop(n2);

int j2=b.Count();

for(int i1=0;i1<=j2;i1++)

a.Push(b.Pop(n2));

int j3=c.Count();

int time1;

cout<<“请输入离开时间: ”;

cin>>time1;

while(time1<0||time1>23)

{

cout<<“请输入正确的时间(0~23时): ”;

cin>>time1;

}

int day=0;

if(time1

{

cout<<“离开时间已小于进入时间!请加上停留天数(天):”;

cin>>day;

while(day<=0)

{

cout<<“输入的天数必须大于0：”;

cin>>day;

}

}

cout<<“您的费用是(元): ”<<(time1-time[n2-1]+24*day)*money<

for(int i2=0;i2<(j+1-n2);i2++)

time[n2-1+i2]=time[n2+i2];

t1--;

if(j3!=0)

{

a.Push(c.DeQueue());

cout<<“ttt通知: 便道车辆请进入停车场!”<

cout<<“请输入进入时间: ”;

cin>>time[t1];

while(time[t1]<0||time[t1]>=24)

{

cout<<“请输入正确的时间(0~23时):”;

cin>>time[t1];

}

t1++;

}

}catch(char *s){cout<

break;

case 3:

a.PrintStack();break;

case 4:

int n3;

cout<<“请输入离开车辆的车牌号: ”;

cin>>n3;try{

c.xzDeQueue(n3);}catch(char*s){cout<

break;

case 5:

cout<<“请输入单价: ”;

cin>>money;

cout<<“修改成功!”<

cout<<“当前停车场的费用是:”<

break;

case 6:

xh1=0;

break;

} } system(“pause”);}

心得体会:

完成时间:2010-10-30

第四篇：实验总结报告-栈和队列

实验总结报告—栈和队列

学号：

姓名： 时间：

一、目的 1.做实验的目的

加深对线性结构栈和队列的理解，学会定义栈和队列的存储结构，加强对栈和队列操作机制的理解，掌握栈和队列的基本操作，了解栈和队列的一些应用。2.撰写实验报告的目的

对本次实验情况进行总结，加强对实验内容的理解，对实验过程有一个系统的认识，从中获得本次试验的经验，并对实验结果进行适当的分析，加深对栈和队列的理解和认识。

二、内容

1.说明实验次数及实验内容 本次实验用一次实验课时完成 实验内容：

（1）、编写函数CreatStack_sq(), DestoryStack_sq(), Push_sq(), Pop_sq(),StackEmpty_sq()和

StackTraverse_sq(),分别完成创建空栈,销毁栈,入栈,出栈,判断栈是否为空,遍历栈底到栈顶依

次打印栈内元素等功能(不要修改原栈),完成后进行测试。测试要求:在main 中,建立栈；判断栈是否为空；将0~9 入栈；将栈顶两个元素出栈, 两元素求和后再入栈；从栈底到栈顶依次打印元素,再从栈顶到栈底打印元素；销毁栈。

void CreatStack_sq(SqStack &S, int msize = STACK_INIT_SIZE){...} void DestoryStack_sq(SqStack &S){...}void Push_sq(SqStack &S, ElementType e){...} bool Pop_sq(SqStack &S, ElementType &e){...} bool StackEmpty_sq(SqStack S){...} bool StackTraverse_sq(SqStack S){...}（2）、编写函数, CreateQueue_L(), DestoryQueue_L(), EnQueue_L(),DeQueue_L(),分别完

成创建队列,销毁队列,入队列,出队列等操作,完成后进行测试。测试要求:在主程序中,建立队列,将0~9 依次入队列,按入队列顺序出队列并打印, 销毁队列。

void CreateQueue_L(LinkQueue &Q){ } void DestoryQueue_L(LinkQueue &Q){ } void EnQueue_L(LinkQueue &Q,int e){ } bool DeQueue_L(LinkQueue &Q, int &e){ }（3）、回文是指正读反读均相同的字符序列,如”abba”和”abdba”均是回文, 但”good”不是回文。根据第四章栈和队列所学内容,试写一个算法判

定给定的字符向量是否为回文。测试数据: 2.1 char* ch = “abccba”;2.2 char* ch = “abccbd”;（4）、(附加题)编写函数void Knapsack(int w[],int T,int n),完成背包求解问题。测试数据: w[6] = {2,8,6,5,1,4};2.做实验完成情况

实验内容在实验课时时间内完成（提前编写了大概1/3部分的代码），选做内容也完成。

本次实验内容较多，为使代码看着简洁有条理，采用了建工程的方式。栈部分：

自定义了头文件 L_stack.h： /*自定义头文件*/ #include

#define STACK_INIT_SIZE 100;#define STACKINCREMENT 100;

/*自定义头文件（栈相关）*/

#include typedef char ElemType;//typedef int ElemType;

/*栈的结构体定义*/ typedef struct{

ElemType *elem;int top;int stacksize;}SqStack;

void CreateStack_sq(SqStack &S,int msize);//创建栈，msize为栈的大小 void DestroyStack_sq(SqStack &S);//销毁栈

void Push(SqStack &S, ElemType e);// 进栈操作，e为入栈元素 int Pop_sq(SqStack &S, ElemType &e);//出站操作，成功返回0，不成功返回-1 void Increment(SqStack &S, int inc_size);//增加栈空间 int StackEmpty_sq(SqStack S);//判断栈空，栈空返回0，栈非空返回-1； void StackTraverse_sq1(SqStack S);//遍历栈底到栈顶，若栈非空则依次打印栈中元素

void StackTraverse_sq2(SqStack S);//遍历栈顶到栈底，若栈非空则依次打印栈中元素

void Test_sq();//栈的检测程序

void MatchBracket_sq(char exp[]);// 括号匹配 void MatchWord_sq(char exp[]);//判断回文 void knapsack(int w[], int T, int n);//背包问题

在头文件中对所有要用到的自定义函数进行了声明，各函数的功能可见代码注释部分。

栈的创建：

#include“L_stack.h”

void CreateStack_sq(SqStack &S,int msize){

S.elem = new ElemType[msize];S.stacksize = msize;S.top =-1;}//end CreateStack_sq 此操作完成栈的创建，创建完成得到一个空栈。

栈的销毁：

#include“L_stack.h”

void DestroyStack_sq(SqStack &S){

delete S.elem;S.top =-1;S.stacksize = 0;}//end DestroyStack_sq 此操作将栈销毁。

入栈：

#include“L_stack.h” #include

void Push(SqStack &S, ElemType e){

if(S.top == S.stacksize0;break;case '}':

if(!Pop_sq(S, e)|| e!= '{')matchstat = 0;break;}//end switch ch = *exp++;}//end while

if(matchstat&&StackEmpty_sq(S))printf(“括号匹配n”);else printf(“括号不匹配n”);}//end MatchBracket_sq 该操作完成括号的匹配；

回文判断：

#include“L_stack.h”

void MatchWord_sq(char exp[]){

int i, len=0,flag=1;SqStack S;CreateStack_sq(S, 100);char ch,e;for(i = 0;exp[i]!='';i++)len++;//printf(“%dn”, len);if(len % 2!= 0){ printf(“非回文序列n”);return;}//序列长度为奇数，不可能为回文序列

else{

for(i = 0;i <(len / 2);i++){

ch = exp[i];

Push(S,ch);

}//前一半元素入栈

while(i < len&&flag){

ch = exp[i];

if(!Pop_sq(S, e)|| e!= ch)

flag = 0;

i++;}//end while }//end else if(flag == 1)printf(“回文序列n”);else printf(“非回文序列n”);} 该操作完成回文的判断；

主函数：

#include #include

//元素与栈顶元素不匹配 #include“L_stack.h”

//#define STACK_INIT_SIZE 100;

int main(){

char exp1[20] = { '(', '8', '+', '9', ')', '/', '{', '[', '(', 'a', '*', 'b', ')', '/', '7', ']', '+', '9', '}', '#' }, exp2[20]

=

{

'}'，'8','+', '9',')','/','{','[','(','a','*','b',')','/','7',']','+','9','}','#'}，} exp3[] = “abccba”, exp4[] = “abccbd”;int w[6] = { 2, 8, 6, 5, 1, 4 };Test_sq();MatchBracket_sq(exp1);MatchBracket_sq(exp2);MatchWord_sq(exp3);MatchWord_sq(exp4);//knapsack(w, 10, 6);

system(“pause”);return 0;主函数中调用test()完成栈的检验，以及实现括号匹配和回文判断。实验结果：

为方便后面实现括号匹配和回文判断，我直接将0~9定义成的char型，头文件中ElemType定义成char。

第一步将0~9入栈；第二步从栈底到栈顶遍历栈中元素并打印，可以看出正确创建了栈并成功将0~9入栈；第三、四步将栈顶元素出栈，并分别赋给e[0]、e[1]，打印操作之后的结果可以看出成功操作；第五步将e[0]、e[1]相加并入栈，从遍历栈结果来看成功操作（由于0~9存的是char型，所以是ASCII码相加得到q）；第六步从栈顶到栈底遍历栈中元素，操作正确；第七步销毁栈，从遍历栈的结果来看成功销毁栈。到此栈的功能检验结束。然后进行括号匹配和回文判断，结果正确。

接下来利用栈进行背包问题：

由于背包问题是对int型数据进行处理，为了偷点懒直接在上面的程序中进行修改

首先将头文件中ElemType定义为int;背包问题中用到的函数为 CreateStack_sq()、Pop_sq()、Push()、StackTraverse_sq1()、StackEmpty_sq()、DestroyStack_sq()，对这些函数涉及到char型的改成int型；然后将主函数中test()、MatchBracket_sq()、MatchWord_sq()注释掉；最后调用背包问题的函数： #include“L_stack.h”

void knapsack(int w[], int T, int n){

SqStack S;int k = 0,r;CreateStack_sq(S, 100);do{

while(T > 0 && k < n){

if(T-w[k] >= 0){ Push(S, k);T-= w[k];}//end if k++;}//end while if(T == 0){

}

} printf(“The Result is:n”);StackTraverse_sq1(S);if(!StackEmpty_sq(S)){

r=Pop_sq(S, k);T += w[k];k++;}//end if } while(!StackEmpty_sq(S)|| k!= n);DestroyStack_sq(S);主函数：

#include #include #include“L_stack.h”

//#define STACK_INIT_SIZE 100;

int main(){

char exp1[20] = { '(', '8', '+', '9', ')', '/', '{', '[', '(', 'a', '*', 'b', ')', '/', '7', ']', '+', '9', '}', '#' }，exp2[20] = { '}', '8','+', '9',')','/','{','[','(','a','*','b',')','/','7',']','+','9','}','#'}，} 输出结果： exp3[] = “abccba”, exp4[] = “abccbd”;int w[6] = { 2, 8, 6, 5, 1, 4 };//Test_sq();//MatchBracket_sq(exp1);//MatchBracket_sq(exp2);//MatchWord_sq(exp3);//MatchWord_sq(exp4);knapsack(w, 10, 6);

system(“pause”);return 0;

可见操作正确。队列部分： 自定义了头文件 Queue.h： /*自定义头文件*/

#include /*队列的结构体定义*/ typedef struct LNode{ int data;struct LNode *next;}LNode,*LinkList;

typedef LinkList Queueptr;

typedef struct{ Queueptr front;Queueptr rear;}LinkQueue;

/*自定义函数*/ void CreateQueue_L(LinkQueue &Q);//创建队列 void DestroyQueue_L(LinkQueue &Q);//销毁队列 void EnQueue_L(LinkQueue &Q, int e);//入队列操作

int DeQueue_L(LinkQueue &Q, int &e);//出队列操作，并将队首元素赋给e，返回1，队空返回0 void QueueTraverse_L(LinkQueue Q);//遍历队列元素并打印 void test();//检查队列是否正确

头文件中声明了需要用到的自定义函数，各个函数的功能见注释

创建队列：

void CreateQueue_L(LinkQueue &Q){

Q.front = Q.rear = new LNode;Q.front->next = NULL;}//end CreateQueue_L 销毁队列：

#include“Queue.h”

void DestroyQueue_L(LinkQueue &Q){

while(Q.front){

Q.rear = Q.front->next;delete Q.front;Q.front = Q.rear;}//end while }//end DestroyQueue_L 进队列： #include“Queue.h”

void EnQueue_L(LinkQueue &Q, int e){

LinkList p;p = new LNode;p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;}//end EnQueue_L 出队列：

#include“Queue.h”

int DeQueue_L(LinkQueue &Q, int &e){

LinkList p;p = new LNode;if(Q.front == Q.rear)return 0;p = Q.front->next;Q.front->next = p->next;

e = p->data;if(Q.rear == p)Q.rear = Q.front;delete p;return 1;}//end DeQueue_L 主函数：

#include #include #include“Queue.h”

int main(){

} 主函数调用test()函数检验队列的正确性 test()函数： #include“Queue.h” system(“pause”);return 0;test();void test(){

} 输出结果： LinkQueue Q;int i,a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },b[10],r[10];CreateQueue_L(Q);for(i = 0;i < 10;i++)EnQueue_L(Q, a[i]);QueueTraverse_L(Q);for(i = 0;i < 10;i++){

} r[i] = DeQueue_L(Q, b[i]);QueueTraverse_L(Q);

从输出结果来看符合要求，队列正确。

三、总结

第五篇：实验三

白酒行业网络营销现状分析

电子商务1003班

李小帅

20101503

一、概述

近年来，随着网络技术的不断发展和网民数量的不断增加，网络营销逐渐兴 起，各行各业开始借助网络开展市场营销活动。但是，在白酒行业，网络营销的 应用还并不广泛。据中国互联网数据中心 DCCI2011 年的统计资料显示，2011 年 上半年食品饮料行业在互联网营销方面的费用仅仅占到所有行业网络营销费用 的 3%。（可见，白酒行业费用占比更小）。而从网络营销所采用的方式看，国内白酒企业大多会采用两种方式来进行网 络营销：第一，建立自己的网站或博客，在网站或博客上发布企业新闻、产品信 息以及线下活动信息；第二，在较大的门户网站、地方网站和行业网站上发布广 告（以图片或 flash 动画形式）。除此之外，还有一些白酒企业通过电子商务的方式建立起了网络销售渠道。但由于白酒运输问题、销售渠道价格差异问题和白酒消费群体上网习惯等问题，白酒电子商务发展速度及规模并没有像其他行业那样的快和大。但是，随着网络技术的不断发展、网民年龄的不断增大、网络购物习惯的逐 渐形成，中国网民的年龄结构与国内白酒消费者年龄结构已经渐渐趋向一致，据 中国互联网络信息中心 2011 年 7 月发布的 《第 28 次中国互联网络发展状况统计 报告》显示，中国网民中 20 岁到 50 岁的网民数量已经占据全部网民总数的 65.6%，而在中国，白酒消费群体主要集中在 25 至 45 岁，所以，国内白酒行业 网络营销的基础已经形成。

二、国内白酒企业网络营销典型案例分析

1、洋河论坛营销分析

2010 年，洋河集团通过和烟台论坛合作，借助烟台论坛的人气，以在烟台 论坛建立论坛专区，发布企业及产品信息、线下活动信息等方式，促使洋河产品在烟台的旺销和品牌的快速传播。营销成功原因分析： 1.产品、品牌因素：产品价位区间宽，品牌知名度大 2.网络平台的选择：烟台论坛人气足，影响力大 3.营销活动内容：除了在论坛上发布企业及产品信息、广告等内容，同时 分阶段发布线下活动信息，使得产品、品牌的传播从线上到线下逐步扩散。

2、五粮液红酒博客营销

五粮液国邑干红与国内知名网络营销企业博拉合作，利用博客发布红酒 试饮活动信息，吸引网民参与活动，而后在众多报名者中依条件挑选若干人 参与试饮；试饮完毕，试饮者在通过博客给予产品体验反馈。营销成功原因分析： 1.产品、品牌因素：品牌知名度大 2.网络平台的选择：博客关注度大 3.营销活动内容：线上组织，线下活动。影响范围广。

3、酒仙网的网络营销

酒仙网是最近两年逐渐兴起的白酒 B2C 电子商务企业，它借助强大的资金 实力与市场营销力度和国内众白酒企业达成合作协议，并且采用气囊包装方 法，解决了少量白酒长途运输的问题。目前，它还与淘宝、拍拍等国内知名 B2C 电子商务企业合作，在其网站上开设酒仙网电子商城。目前，在淘宝、拍 拍上输入“白酒”，搜索结果中排名第一位的就是酒仙网电子商城。

三、总结 与传统的市场营销相比，目前国内白酒企业网络营销缺乏系统性和持续性，网络营销做得较为有成效的企业也大多是借助自身多年的品牌优势及高人气的 网络平台实现短期促销目标。此外，近些年来，酒仙网等白酒 B2C 企业兴起，有逐渐带动白酒网络销售的 趋势。加之中国网民与白酒消费者两者交集逐渐增大，白酒网络销售是值得白酒企业密切关注的营销方式。