算法导论_第十章_基本数据结构

最新推荐文章于 2021-05-08 06:31:12 发布
最新推荐文章于 2021-05-08 06:31:12 发布
阅读量589 收藏
点赞数
分类专栏： 算法 笔记 算法导论 文章标签： 数据结构 算法导论 链表 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chudongfang2015/article/details/51790726
版权
算法 同时被 3 个专栏收录
116 篇文章 1 订阅
订阅专栏
笔记
12 篇文章 0 订阅
订阅专栏
算法导论
10 篇文章 0 订阅
订阅专栏


算法导论_第十章_基本数据结构

队列和栈：


队列为先进先出，栈为先进后出。


其可以用数组和链表实现。



队列代码如下：

/*************************************************************************
	> File Name: queue.cpp
	> Author:chudongfang 
	> Mail:1149669942@qq.com 
	> Created Time: 2016年06月30日 星期四 10时39分08秒
 ************************************************************************/

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include <algorithm>
#define INF 0x3f3f3f3f
#define LEN 5
using namespace std;
typedef long long ll;

int dequeue();
int enqueue(int x);
bool queue_empty();
bool queue_full();

int queue[LEN+1];
int head=1,tail=1;
int main(int argc,char *argv[])
{
    enqueue(1);
    for(int i=1;i<=LEN;i++)  printf("%d ",queue[i]);
    printf("\nhead=%d\ntail=%d\n\n",head,tail);
    
    enqueue(2);
    for(int i=1;i<=LEN;i++)  printf("%d ",queue[i]);
    printf("\nhead=%d\ntail=%d\n\n",head,tail);
    
    enqueue(3);
    for(int i=1;i<=LEN;i++)  printf("%d ",queue[i]);
    printf("\nhead=%d\ntail=%d\n\n",head,tail);
    
    printf("%d\n",dequeue());
    for(int i=1;i<=LEN;i++)  printf("%d ",queue[i]);
    printf("\nhead=%d\ntail=%d\n\n",head,tail);
    
    enqueue(1);
    for(int i=1;i<=LEN;i++)  printf("%d ",queue[i]);
    printf("\nhead=%d\ntail=%d\n\n",head,tail);
    
    enqueue(2);
    for(int i=1;i<=LEN;i++)  printf("%d ",queue[i]);
    printf("\nhead=%d\ntail=%d\n\n",head,tail);
    
    enqueue(3);
    for(int i=1;i<=LEN;i++)  printf("%d ",queue[i]);
    printf("\nhead=%d\ntail=%d\n\n",head,tail);
    

    return 0;
}

int enqueue(int x)//入队
{
    if(queue_full()) 
    {
        printf("the queue is full!\n");
        return 0;
    }
    queue[tail]=x;
    if(tail==LEN)  
        tail=1;
    else 
        tail++;
}


int dequeue()//出队
{
    if(queue_empty())
    {
        printf("the queue is empty!");
        return 0;
    }

    int x=queue[head];
    if(head==LEN) 
        head=1;
    else 
        head++;
    return x;
}

bool queue_empty()//判断是否为空
{
    if(tail==head)  return true;
    else            return false;
}

bool queue_full()//判断是否满
{
    if(head==tail+1||head==1&&tail==LEN)   return  true;
    else               return  false;
}


栈代码如下：

/*************************************************************************
	> File Name: stack.cpp
	> Author:chudongfang 
	> Mail:1149669942@qq.com 
	> Created Time: 2016年06月30日 星期四 10时28分24秒
 ************************************************************************/

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
int push(int key);
bool stack_empty();
int pop();
int stack[100];
int top=0;
int main(int argc,char *argv[])
{
    memset(stack,0,sizeof(stack));
    push(1);
    for(int i=1;i<=10;i++)
        printf("%d",stack[i]);
    printf("\ntop=%d\n",top);
    push(3);
    for(int i=1;i<=10;i++)
        printf("%d",stack[i]);
    printf("\ntop=%d\n",top);
    
    printf("pop=%d",pop());

    return 0;
}
int push(int key)//入栈
{
    top++;
    stack[top]=key;
}


bool stack_empty()//判断栈是否为空
{
    if(top==0)   return true;
    else         return false;
}


int pop()//出栈
{
    if(stack_empty())  
    {
        printf("the stack is empty!");
        return 0;
    }
    else
        return stack[top--];
}





链表：


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


其与数组不同的是，其在内存中不连续，用指针链接起来




指针和对象的实现


1.对象的多数组表示：


对象的每一个属性使用一个数组表示，可以用来表示

一组有相同属性的对象。


一个对象的所有属性的数组下标相同


key[]储存其关键值

next[]储存下一个节点位置

prev[]储存上一个节点位置


具体代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;

int main(int argc,char *argv[])
{
    //该数组链表用来储存9->1->3
    int arry[20];

    memset(arry,0,sizeof(arry));
    int head=3;

    arry[3]=9;   //key
    arry[3+1] =7;//next
    arry[3+2] =0;//prev
   
   	arry[7]   =1;
    arry[7+1] =14;
    arry[7+2] =3;
   	
   	arry[14]  =3;
    arry[14+1] =0;
    arry[14+2] =7;

    for(int i=1;i<=19;i++)
    	printf("%d ",arry[i]);

    return 0;
}





2.对象的单数组表示


在一个数组中指针仅仅是该对象所在的第一个储存单元的地址，

要访问对象其他储存单元可以在指针上加上一个偏移量。


例如keynext prev对应的偏移量分别为0,1,2


则访问其时只需根据偏移量找到其元素


下面看例子的对应代码：

/*************************************************************************
	> File Name: single_attay.cpp
	> Author:chudongfang 
	> Mail:1149669942@qq.com 
	> Created Time: 2016年06月30日 星期四 11时08分58秒
 ************************************************************************/


#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include <algorithm>
#define INF 0x3f3f3f3f
#define N 6
using namespace std;
typedef long long ll;

int main(int argc,char *argv[])
{
    //该数组链表用来储存9->1->3
    int next[N];//下一个节点位置
    int key[N];//关键值
    int prev[N];//上一个节点位置
    int head;
    memset(next,0,sizeof(next));
    memset(key,0,sizeof(key));
    memset(prev,0,sizeof(prev));
    head=3;

    key[3] =9;
    next[3]=5;
    
    key[5] =1;
    next[5]=2;
    prev[5]=3;
    
    prev[2]=5;
    key[2] =3;
        
    for(int i=1;i<N;i++)
        printf("%d ",next[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",key[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",prev[i]);

    return 0;
}








对象的分配与释放


用一个头节点为free的链表（自由表），表示其空余的空间，

然后对自由表进行操作，进行空间的分配与释放。



来看代码：

/*************************************************************************
	> File Name: 10.3_objetc.cpp
	> Author:chudongfang 
	> Mail:1149669942@qq.com 
	> Created Time: 2016年06月30日 星期四 09时12分15秒
 ************************************************************************/

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include <algorithm>
#define INF 0x3f3f3f3f
#define N 6
using namespace std;

int _free=0;

int allocate_object(int next[],int key[],int prev[]);
void free_object(int x,int next[]);

typedef long long ll;

int main(int argc,char *argv[])
{
    //该数组链表用来储存9->1->3
    int next[N];
    int key[N];
    int prev[N];
    int head;
    memset(next,0,sizeof(next));
    memset(key,0,sizeof(key));
    memset(prev,0,sizeof(prev));
    head=3;

    key[3] =9;
    next[3]=5;
    
    key[5] =1;
    next[5]=2;
    prev[5]=3;
    
    prev[2]=5;
    key[2] =3;
    
    
    for(int i=1;i<N;i++)
        printf("%d ",next[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",key[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",prev[i]);
    printf("\nfree=%d\n",_free);



    _free=1;//空链表头节点
    next[1]=4;
    printf("\n\n");
    for(int i=1;i<N;i++)
        printf("%d ",next[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",key[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",prev[i]);
    printf("\nfree=%d\n",_free);

    int temp=allocate_object(next,key,prev);
    if(temp==0)   printf("无可用的节点！\n");
    else 
        printf("\n\n%d可用",temp);//返回一个空的节点
    printf("\nfree=%d\n\n\n\n",_free);
    
    
    
    free_object(5,next);//释放节点5后的情况

    for(int i=1;i<N;i++)
        printf("%d ",next[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",key[i]);
    printf("\n");
    for(int i=1;i<N;i++)
        printf("%d ",prev[i]);
    printf("\nfree=%d\n",_free);

    return 0;
}
int allocate_object(int next[],int key[],int prev[])//根据空链表，返回一个可用的节点
{
    if(free==0)   return 0;
    else
    {
        int x=_free;
        _free=next[x];
        return x;
    }
}

void free_object(int x,int next[])//释放一个节点，并把其添加到空链表里
{
    next[x]=_free;
    _free=x;
}









其实可以多个链表共有一个自由表，而且多个链表和自由表位置上

可能交错在一起，不过一个位置只能属于一个链表。



有根树的表示：



二叉树：


一个二叉树包括其父节点指针，指向左儿子节点的指针和

指向右儿子节点的指针还有其卫星数据。


父节点为NULL的表示其为根节点

如果没有左儿子，左儿子节点为NULL，没有右儿子，则右儿子节点为空。



多叉树：


利用左孩子右兄弟表示法：

每个节点都包含一个父节点指针p，且T.root指向树T的根节点。


其含有另外两个节点：


1.x.left-child指向节点x最左边的孩子节点


2.x.right-sibling指向x右侧的兄弟


如果节点没有孩子节点，则x.left-child为NULL

如果节点x是其父节点的最右孩子，则x.right-sibling为NULL





chudongfang2015
关注
专栏目录
算法导论第十章习题解答
09-18
《算法导论》是计算机科学领域的一本经典教材，它深入浅出地介绍了各种重要的算法，并提供了详尽的分析和实现。第十章通常涉及到图算法，这是计算机科学中不可或缺的一部分，尤其是在网络、路径搜索、最优化问题等...
严魏敏-习题-树与二叉树-05
最新发布
自学记录
11-28 1万+
123
左子树中最右节点≠左子树中最右叶节点
shuaishuai5213的博客
10-25 5876
若X是二叉中序线索树中一个有左孩子的结点,且X不为根,则X的前驱为
《算法导论》第十章——基本数据结构(栈、队列、链表)
T的博客
10-14 334
  虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！ 10.1栈和队列   栈（stack）又名堆栈，遵循后进先出原则。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称...
《算法导论》第十章——基本数据结构（一）：栈与队列
473687880
10-15 162
引言：算法操作的集合可以随着时间的改变而增大，减小，或者产生其他变化，我们称这种集合是动态的。接下来的五章，我们将研究计算机上表示和操作有穷动态集合的一些基本技术。本文主要为你讲解栈与队列的操作和实现，建议将这些操作制作成库，方便以后的引用，避免重复编码。系列文章为算法导论的笔记和相关习题解答。 本文来源：栈与队列 动态集合的元素 元素包括两个部分：关键字+卫星数据 动态集合上的操...
27、输出二叉树每一层最右的节点（即二叉树右视图）
sunnnnh的博客
05-08 1696
一、题目 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 示例: 输入:[1,2,3,null,5,null,4] 输出:[1, 3, 4] 解释: 1 <--- / \ 2 3 <--- \ \ 5 4 <--- 二、实现 思路： 利用 BFS 进行层次遍历，记录下每层的最后一个元素。 时间复杂度： O(N)O(N)，每个节点都入队出队了...
Python基础入门教程 Python语言编程导论10 第十章 python的GUI编程 （共107页）.ppt
09-25
【Python基础入门教程 Python语言编程导论】课程列表 Python基础入门教程 Python语言编程导论 Python应用案例1 （共12页）.ppt ...Python基础入门教程 Python语言编程导论10 第十章 python的GUI编程 （共107页）.ppt
算法导论第1-16章编程题答案
08-21
《算法导论》是计算机科学领域的一本经典著作，它深入浅出地介绍了各种重要的算法，并配以详尽的分析和实例。这份压缩包文件包含了该书第1至16章的部分编程题目的Java实现，对于学习算法和提高编程技能来说，是一个...
计算机算法导论
08-07
9. **第十章**：可能探讨概率和随机化算法，如Monte Carlo方法和Las Vegas算法，以及它们在计算中的应用。 10. **第十一章**：可能涵盖近似算法和NP完全问题，介绍如何在无法找到精确解的情况下寻找接近最优的解决...
算法导论第十章基本数据结构
z84616995z的专栏
02-14 5520
10.1栈与队列 （1） 栈 概念定义：栈属于动态集合，采用先进后出策略（LIFO）。基本操作是压入（PUSH）和弹出（POP）。如果s.top=0，表示栈空，如果试图对空栈进行POP操作会发生下溢（underflow）。如果s.top>n,表示栈满，如果进行PUSH操作会发生上溢（overflow）。 基本代码： //基本的栈操作 #include #include using na
算法导论第十章：基本数据结构
longhuihu的专栏
11-30 1830
引言 数据结构<br />集合：如同在数学中一样，集合也是计算机科学的基础。不过数学上的集合时不变的，而算法所操作的集合是动态改变的。数据结构这一部分介绍在计算机中表示和操作有穷动态集合的一些基本技术。<br /> <br />字典：许多算法要求能够将元素插入集合，从集合中删除元素，以及测试元素是否属于集合。支持这些操作的动态集合就叫字典。另一些算法可能需要更复杂的操作，实现动态集合的最好方案取决于要支持什么样的集合操作。<br /> <br />动态集合上的操作：下面给出一些典型的操作<br />SEAR
算法导论第十章：基本数据结构（一）
FaustoPatton的博客
03-23 249
栈和队列 栈和队列是动态集合 栈实现的是一种后进先出（LIFO,last in first out） 队列实现的是一种先进先出（FIFO） 栈（stack） 栈的操作有两个，一个是压入（PUSH），一个是弹出（POP） 对空栈执行POP操作，会导致一个错误——栈下溢（underflow） 如果栈顶元素超出栈的大小，那么则导致另外一个错误——栈上溢（overflow） 队列（QUEU...
算法导论第十章 基本数据结构实现（栈，队列，链表），课后题答案
shitangdejiaozi的博客
10-19 831
栈栈实现一种后进先出的策略，入栈和出栈，都是通过栈顶指针来操作。#include <stdio.h> #include <stdbool.h> #include <time.h> #include <stdlib.h>#define SIZE 10 typedef struct{ int array[SIZE]; int top; }T_stack;bool Empty(T_stac
算法导论答案 第10章：基本数据结构
ssyyifa的专栏
11-23 994
10.1 栈和队列 10.1-2
算法导论 第10章 思考题
幸福在路上
09-19 4070
10-1 列表之间的比较   未排序的单链表 已排序的单 未排序的双链表 已排序的双链表 SEARCH(L, k) n n n n INSERT(L, x) 1 n 1 n DELETE(L, x) n n 1 1 SUCCESSOR(L, x) 1 1 1 1 PREDECESSOR(L,
算法导论 第十章 基本数据结构
gainsuper的专栏
01-05 512
基本数据结构10.1 栈和队列栈（LIFO）栈和队列都是动态集合，且在其上进行DELETE操作所移除的元素都是预先设定的。STACK-EMPTY(S) if S.top==0 return TRUE else return FALSEPUSH(S, x) S.top=S.top+1 S[S.top]=xPOP(S) if STA
算法导论第三版第十章 单链表实现栈和队列（思路简单清晰）
u012677715的博客
12-09 461
1.单链表实现栈 虽然以数组结构来实现栈的好处是算法设计简单，但如果栈的大小可改变的话，由于数组的大小需事先声明，这时必须使用最大可能性的数组空间来考虑，这样会造成内存空间的浪费。而利用链表来实现栈的优点是随时可以动态改变链表长度。代码如下： #include #include #include using namespace std; class listnode { public: in
算法导论: 第十章
dummyedu的专栏
01-19 2085
 栈，队列， 链表， 树， 很熟的结构， 没有很多的特别。 
算法导论第十章总结以及课后题答案
wk_bjut_edu_cn的博客
03-05 2291
基本数据结构 总结 都是些基础知识 课后题答案 10.1-6 说明如何用两个栈实现一个队列，并分析相关队列操作的运行时间。 假定S1和S2是两个栈，Q是一个队列。 ENQUEUE operation: ENQUEUE(Q,x) //x是要插入队列的元素 PUSH(S1,x) 就相当于在栈中插入元素，所以时间复杂度为O(1)。 DEQUEUE operation DE
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值