大数据结构与算法源代码.docx
《大数据结构与算法源代码.docx》由会员分享,可在线阅读,更多相关《大数据结构与算法源代码.docx(215页珍藏版)》请在冰豆网上搜索。
![大数据结构与算法源代码.docx](https://file1.bdocx.com/fileroot1/2023-7/7/0649663b-4662-437b-b286-4f5cc0db9ef2/0649663b-4662-437b-b286-4f5cc0db9ef21.gif)
大数据结构与算法源代码
课程说明:
数据结构一共四天课程,day01~~~day04.
CSDDataStructureDAY01
1.基于顺序表的堆栈
2.基于链式表的堆栈
1基于顺序表的堆栈
栈是一种特殊的线性表,是限定在线性表表尾进行插入删除操作的线性表。
由栈的概念衍生出几个子概念,它们是:
1)栈顶,即允许进行插入、删除操作的一端,又称为表尾,用栈顶指针()来指示栈顶元素。
2)栈底,即固定端,又称为表头
3)空栈,即栈当中没有数据元素。
顺序栈是采用顺序存储结构的栈,即使用一组连续的存储单元(一般使用数组)来模拟栈,依次存放栈中的数据元素。
1.1方案
顺序栈的基本操作包括:
1)初始化操作,在初始化操作中将建立一个空栈。
2)判断栈空,判断栈中的数据元素个数是否为0。
3)入栈,在栈中加入一个数据元素。
4)出栈,在栈中删除一个数据元素。
5)取栈顶元素,将栈顶元素取出,但并不在栈中删除该元素。
1.2步骤
实现此案例需要按照如下步骤进行。
步骤一:
定义栈
在C语言中:
1)定义一个一维数组来表示栈的顺序存储空间。
2)定义一个变量来指出栈顶的位置。
3)这两方面的信息共同描述一个栈,可将它们用结构体封装在一起。
代码如下:
1.#defineLISTSIZE10
2.typedefintDataType;
3.structStack{
4.DataTypedata[LISTSIZE];
5.int;//除了记录大小还可以记录栈顶位置
6.};
上述代码中,以下代码:
1.#defineLISTSIZE100
是用一个宏常量来定义顺序表的容量,这样定义的好处是当需要修改顺序表的容量的时候,只需要修改该宏常量即可。
上述代码中,以下代码:
1.typedefintDataType;
是将数据类型int起了一个别名叫做DataType,并在后面的程序中只使用DataType,而不使用int。
这样做的好处是当堆栈中的数据类型发生变化时,只需要修改此句中的int为要改变的数据类型,即可将程序中所有数据变量的数据类型变成指定的类型。
步骤二:
初始化操作
在主程序中,定义栈结构体的变量。
在初始化函数中将该变量中的栈顶指针初始化为0,表示为空栈。
代码如下:
1.voidinit(structStack*stack)
2.{
3.stack->=0;
4.}
5.intmain(intargc,constchar*argv[])
6.{
7.structStackstack;
8.init(&stack);
9.}
步骤三:
判断栈空
判断栈空实际上是判断栈顶指针是否为0,因为当栈顶指针为0时,代表栈中没有数据元素。
代码如下:
1.boolempty(structStack*stack){
2.returnstack->==0;
3.}
步骤四:
入栈
入栈是在栈中加入一个数据元素,在入栈时,首先需要判断栈是否为满,如果栈满了,则就不能在向其中添加元素了,判断栈是否满的操作只有在顺序存储结构才会出现,因为采用顺序存储结构的栈是要事先定义栈的容量的。
然后将数据元素放入栈中,并使栈顶指针加1,指向下一个位置。
代码如下:
1.voidpush(structStack*stack,DataTyped){
2.if(stack->==LISTSIZE)
3.return;
4.stack->data[stack->++]=d;
5.}
上述代码中,以下代码:
1.if(stack->==LISTSIZE)
是判断栈是否满,判断栈顶指针是否与栈的容量相等,如果是,则表示栈已经满了。
步骤五:
出栈
出栈操作实际上是将栈中的栈顶元素删除,在出栈时,首先判断栈是否为空,如果栈为空则代表栈中已经没有数据元素了,此时是不可能进行出栈操作的。
然后,将栈顶指针减1。
代码如下:
1.voidpop(structStack*stack){
2.if(empty(stack))
3.return;
4.stack->--;
5.}
步骤六:
取栈顶元素
取栈顶元素操作实际上是仅返回栈顶元素,而栈顶指针并不变动。
在取栈顶元素时,首先也要判断栈是否为空,因为空栈同样是不可能有数据元素的。
代码如下:
1.DataTypeData(structStack*stack){
2.returnstack->data[stack->-1];
3.}
1.3完整代码
本案例的完整代码如下所示:
1.#include
2.#include
3.
4.#defineLISTSIZE10
5.typedefintDataType;
6.structStack{
7.DataTypedata[LISTSIZE];
8.int;//处了记录大小还可以记录栈顶位置
9.};
10.
11.voidinit(structStack*stack)
12.{
13.stack->=0;
14.}
15.
16.boolempty(structStack*stack){
17.returnstack->==0;
18.}
19.
20.voidpush(structStack*stack,DataTyped){
21.if(stack->==LISTSIZE)
22.return;
23.stack->data[stack->++]=d;
24.}
25.
26.voidpop(structStack*stack){
27.if(empty(stack))
28.return;
29.stack->--;
30.}
31.
32.DataTypeData(structStack*stack){
33.returnstack->data[stack->-1];
34.}
35.
36.
37.intmain()
38.{
39.structStackstack;
40.init(&stack);
41.push(&stack,30);
42.push(&stack,60);
43.push(&stack,80);
44.
45.while(!
empty(&stack)){
46.printf("%d",Data(&stack));
47.pop(&stack);
48.}
49.printf("\n");
50.
51.return0;
52.}
2基于链式表的堆栈
2.1问题
链栈是采用链式存储结构的栈,即使用一组不要求连续的存储空间来模拟栈。
每个栈元素为一个节点,每个节点中包含两个域,一个是数据域,用于存储栈元素的数据;另一个是指针域,用于存储下一个栈元素的地址。
2.2方案
链栈的基本操作包括:
1)初始化操作,在初始化操作中将栈顶指针置空。
2)判断栈空,判断栈顶指针是否为空。
3)入栈,在栈中加入一个数据元素。
4)出栈,在栈中删除一个数据元素。
5)取栈顶元素,将栈顶元素取出,但并不在栈中删除该元素。
2.3步骤
实现此案例需要按照如下步骤进行。
步骤一:
定义栈元素节点
在C语言中:
1)定义一个变量来表示栈元素的数据。
2)定义一个指针来指向下一个栈元素的位置。
3)这两方面的信息共同描述一个栈元素节点,可将它们用结构体封装在一起。
代码如下:
1.typedefintDataType;
2.structStack{
3.DataTypedata;
4.structStack*next;
5.};
上述代码中,以下代码:
1.structStack*next;
是定义了一个指向下一个栈元素的指针,由于下一个栈元素的数据类型与当前栈元素的数据类型相同,所以指针的数据类型就是栈节点的指针数据类型。
步骤二:
初始化操作
在主程序中,定义栈顶指针。
在初始化函数中将栈顶指针初始化为NULL,表示为空栈。
代码如下:
1.voidinit(structStack**)
2.{
3.*=NULL;
4.}
5.intmain()
6.{
7.structStack*;
8.init(&);
9.return0;
10.}
上述代码中,以下代码:
1.voidinit(structStack**)
定义了初始化函数的函数头,该函数有一个形参,是栈元素结构体指针的指针。
之所以使用指针的指针,是因为栈顶指针在函数执行过程中会被置空,而这种变化需要带回主函数。
步骤三:
判断栈空
判断栈空操作实际上就是判断栈顶指针是否为空。
代码如下所示:
1.boolempty(structStack*)
2.{
3.return==NULL;
4.}
步骤四:
入栈
入栈操作实际上就是在栈中加入一个数据元素,对于链栈,入栈操作本质上就是在栈中加入一个结点。
代码如下所示:
1.voidpush(structStack**,DataTyped)
2.{
3.structStack*newNode=(structStack*)malloc(sizeof(structStack));
4.newNode->data=d;
5.newNode->next=*;
6.*=newNode;
7.}
上述代码中,以下代码:
1.voidpush(structStack**,DataTyped)
定义了入栈函数的函数头,该函数有两个形参,第一个是栈结构的指针的指针,在这里使用指针的指针,还是因为需要将栈顶指针的变化带回主函数。
第二个形参是需要入栈的数据。
上述代码中,以下代码:
1.structStack*newNode=(structStack*)malloc(sizeof(structStack));
是构造一个新的栈元素节点。
上述代码中,以下代码:
1.newNode->data=d;
是将需要入栈的元素放入新的栈元素节点中。
上述代码中,以下代码:
1.newNode->next=*;
是将新创建的栈元素节点加入到栈中原栈顶元素的前面,成为新的栈顶元素。
上述代码中,以下代码:
1.*=newNode;
是栈顶指针指向新创建的栈顶元素。
正是由于这行代码,使栈顶指针发生了变化,而这种变化需要带回到主程序,所以函数的第一个形参必须是指针的指针。
步骤五:
出栈
出栈操作实际上就是从栈中删除栈顶位置的元素,对于链栈,出栈操作本质上就是在栈中删除一个结点。
代码如下所示:
1.voidpop(structStack**)
2.{
3.if(empty(*))
4.return;
5.structStack*tempNode=*;
6.*=(*)->next;
7.free(tempNode);
8.}
上述代码中,以下代码:
1.if(empty(*))
2.return;
是判断链栈是否为空,如果栈为空是不能从栈中删除元素的。
上述代码中,以下代码:
1.structStack*tempNode=*;
2.*=(*)->next;
3.free(tempNode);
首先用一个临时指针保存原栈顶指针指向的栈元素地址,即出栈元素的地址,然后将栈顶指针指向下一个元素,这样栈中就减少了一个元素。
最后释放临时指针指向的元素,即释放出栈元素所占的存储空间。
步骤六:
取栈顶元素
取栈顶元素实际上就是将栈顶元素的值返回,对于链栈,本质上是将栈顶节点的数据返回。
注意,在取栈顶元素时,首先要判断栈是否为空,空栈是没有数据元素的。
代码如下:
1.voidData(structStack*,DataType*data)
2.{
3.if(empty())
4.return;
5.*data=->data;
6.}
2.4完整代码
本案例的完整代码如下所示:
1.#include
2.#include
3.#include
4.
5.typedefintDataType;
6.structStack{
7.DataTypedata;
8.structStack*next;
9.};
10.
11.voidinit(structStack**)
12.{
13.*=NULL;
14.}
15.
16.boolempty(structStack*)
17.{
18.return==NULL;
19.}
20.
21.voidpush(structStack**,DataTyped)
22.{
23.structStack*newNode=(structStack*)malloc(sizeof(structStack));
24.newNode->data=d;
25.newNode->next=*;
26.*=newNode;
27.}
28.
29.voidpop(structStack**)
30.{
31.if(empty(*))
32.return;
33.structStack*tempNode=*;
34.*=(*)->next;
35.free(tempNode);
36.}
37.
38.voidData(structStack*,DataType*data)
39.{
40.if(empty())
41.return;
42.*data=->data;
43.}
44.
45.
46.intmain()
47.{
48.structStack*;
49.init(&);
50.push(&,30);
51.push(&,60);
52.push(&,80);
53.
54.while(!
empty()){
55.intdata;
56.Data(,&data);
57.printf("%d",data);
58.pop(&);
59.}
60.printf("\n");
61.
62.return0;
63.}
作业:
11.逆波兰法求解四则运算表达式
在计算机中,表达式的处理是很重要的一项工作。
表达式被分成中缀表达式和后缀表达式两种形式。
所谓中缀表达式就是我们日常书写表达式的方法,操作数在两边,运算符在中间,如1+2。
这种表达式易于理解,但是很难被计算机解析。
为了让计算机能够简单地解析表达式,可采用后缀表达式。
后缀表达式又被称为逆波兰表示法,是将运算符至于操作数的后面,如中缀表达式1+2表示成后缀表达式为12+。
后缀表达式中的一个特点是不需要使用括号,就可以准确地表示表达式的优先级,如中缀表达式1+2*3表示成后缀表达式后为123*-,而中缀表达式(1+2)*3表示成后缀表达式则为12+3*。
本案例的工作是先将中缀表达式转换成后缀表达式,然后计算后缀表达式。
参考答案
实现此案例需要按照如下步骤进行。
步骤一:
定义两个栈
首先,定义一个字符数组,用于存放待转换的字符串。
定义一个“结果栈”,用于存放转换过程中的每一步结果。
定义一个“运算符栈”,用于存放转换过程中的运算符。
代码如下所示:
1.#include
2.#include
3.
4.#defineLISTSIZE10
5.typedefintDataType;
6.
7.structStack{
8.DataTypedata[LISTSIZE];
9.int;//处了记录大小还可以记录栈顶位置
10.};
11.
12.voidinit(structStack*stack)
13.{
14.stack->=0;
15.}
16.
17.voidpush(structStack*stack,DataTyped){
18.stack->data[stack->++]=d;
19.}
20.
21.voidpop(structStack*stack){
22.stack->--;
23.}
24.
25.DataType(structStack*stack){
26.returnstack->data[stack->-1];
27.}
28.
29.boolempty(structStack*stack){
30.returnstack->==0;
31.}
32.
33.boolprior(charop1,charop2){
34.return(op1=='*'||op1=='/')&&(op2=='+'||op2=='-');
35.}
36.
37.intmain(){
38.charexpr[]="1+2*3/(4-1)";
39.structStackres;//结果栈
40.structStackoper;//运算符栈
41.init(&res);
42.init(&oper);
43.}
步骤二:
逐个读取字符串中的字符,直到结束
设置一个循环,逐个从字符数组expr中读取字符,直到遇见字符’\0’。
代码如下所示:
1.#include
2.#include
3.
4.#defineLISTSIZE10
5.typedefintDataType;
6.
7.structStack{
8.DataTypedata[LISTSIZE];
9.int;//处了记录大小还可以记录栈顶位置
10.};
11.
12.voidinit(structStack*stack)
13.{
14.stack->=0;
15.}
16.
17.voidpush(structStack*stack,DataTyped){
18.stack->data[stack->++]=d;
19.}
20.
21.voidpop(structStack*stack){
22.stack->--;
23.}
24.
25.DataType(structStack*stack){
26.returnstack->data[stack->-1];
27.}
28.
29.boolempty(structStack*stack){
30.returnstack->==0;
31.}
32.
33.boolprior(charop1,charop2){
34.return(op1=='*'||op1=='/')&&(op2=='+'||op2=='-');
35.}
36.
37.intmain(){
38.charexpr[]="1+2*3/(4-1)";
39.structStackres;//结果栈
40.structStackoper;//运算符栈
41.init(&res);
42.init(&oper);
43.
44.for(inti=0;expr[i]!
='\0';i++){
45.charch=expr[i];
46.}
47.}
步骤三:
将数字放入“结果栈”中
判断读出的字符是否是数字,如果是数字,则将该数字放入“结果栈”中。
代码如下所示:
1.#include
2.#include
3.
4.#defineLISTSIZE10
5.typedefintDataType;
6.
7.structStack{
8.DataTypedata[LISTSIZE];
9.int;//处了记录大小还可以记录栈顶位置
10.};
11.
12.voidinit(structStack*stack)
13.{
14.stack->=0;
15.}
16.
17.voidpush(structStack*stack,DataTyped){
18.stack->data[stack->++]=d;
19.}
20.
21.voidpop(structStack*stack){
22.stack->--;
23.}
24.
25.DataType(structStack*stack){
26.returnstack->data[stack->-1];
27.}
28.
29.boolempty(structStack*stack){
30.returnstack->==0;
31.}
32.
33.boolprior(charop1,charop2){
34.return(op1=='*'||op1=='/')&&(op2=='+'||op2=='-');
35.}
36.
37.intmain(){
38.charexpr[]="1+2*3/(4-1)";
39.structStackres;//结果栈
40.structStackoper;//运算符栈
41.init(&res);
42.init(&oper);
43.
44.for(inti=0;expr[i]!
='\0';i++){
45.