《啊哈算法》第二章 栈，队列，链表

最新推荐文章于 2021-12-15 21:15:07 发布
最新推荐文章于 2021-12-15 21:15:07 发布
阅读量631 收藏
点赞数
分类专栏： 啊哈算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinchaoji_/article/details/51199800
版权

参考：《啊哈算法》
嗯，抄代码的意义在于你能不能抄正确！
嗯，我又开始了新的学习，任务没有完成哪里还有时间吃饭？不逼逼自己不知道自己的潜力究竟有多大！

本章的基本数据结构都是使用的顺序表实现的！不管那么多，动手才是硬道理，先理解原理才是硬道理。虽然上学期已经学过这个了，但是，。，。，。坚持做自己不想做的，得到别人得不到的。

1，队列。（和标题顺序不符呀）对列就是先进先出。（FIFO)
问题：序列631758924,删除对头，次对头放到队尾，重复操作直到队为空，求删除数字序列（即QQ号）
数组模拟，一个head,一个tail.head++删除头，tail++尾部插入
成功解密QQ号
（注意：判断队空的条件是队头等于队尾。技巧：通常把tail设到队尾的下一位，方便直接添加，比较直观。否则，还要先tail++一次

#include<iostream>
using namespace std;
const int N=100;
int main()
{
    int a[N]={6,3,1,7,5,8,9,2,4},head,tail;
    head=0;
    tail=9;
    //while(head<tail)
    while(a[head]){
        cout<<a[head]<<ends;//输出队头
        head++;//前进到下一位
        a[tail]=a[head];//送到对尾部
        head++;//后移
        tail++;//后移
    }
    cout<<endl;
    return 0;
}

结构体封装的队列（队列三个基本元素，数据内容，队首，队尾）

#include <iostream>
using namespace std;
const int N=100;
typedef struct Que {
    char  data[N];
    int head;
    int tail;
};
int main() {
    cout<<"Please enter the QQ :"<<endl;
    Que q;
    char c;
    int i=0;
    while(cin>>c) {
        q.data[i++]=c;
    }
    int n=i;//i就是总数据数
    q.head=0;
    q.tail=n;
    while(q.head<q.tail) {
        cout<<q.data[q.head]<<ends;
        q.head++;
        q.data[q.tail]=q.data[q.head];
        q.head++;
        q.tail++;
    }
    cout<<endl;
    return 0;
}

嗯，再来一发，STL封装的队列
进队：push()
出队：pop()
队首：.front()
队尾：.back()

#include<iostream>
#include <queue>
using namespace std;
int main()
{
    queue<char> QQ;
    cout<<"Please enter the QQ:"<<endl;
    char c;
    while(cin>>c){
        QQ.push(c);
    }
    while(!QQ.empty()){
        cout<<QQ.front()<<ends;
        QQ.pop();
        QQ.push(QQ.front());
        QQ.pop();
    }
    return 0;
}

2，栈，栈规定只能在一端进行操作，因此栈为后进先出，（FILO)
顺序表表示的话，就是一个栈顶top，top++,top–进出栈
问题：判断字符串是不是回文串

#include<iostream>
using namespace std;
const int N=10;
char str[N];
int main() {
    char c;
    int i=0;
    while(cin>>c) {
        str[i++]=c;
    }
    int n=i;
    int mid=n/2-1;
    int top=0;
    for(int i=0; i<=mid; i++) {
        str[top++]=str[i];
    }
    top=top-1;
    int next;
    if(n%2==0) {
        next=mid+1;
    } else {
        next=mid+2;
    }
    int flag=1;
    for(int i=next; i<n; i++) {
        if(str[i]!=str[top--]) {
                flag=0;
            break;
        }
    }
    if(flag){
        cout<<"YES"<<endl;
    }
    else {
        cout<<"NO"<<endl;
    }
    return 0;
}

(发现个问题，自己看了书，再自己弄一遍的过程中，分析的时候简直是移步到位，越来越多的技巧，比如使用寄存器，计数器，怎么往逻辑外传逻辑内得到的参数值，再比如这里找中点和另一半的起始位置简直了）

STL stack的用法，push,pop,.top()

判断回文串嘛，怎么需要用栈尼，栈用在括号匹配才是硬道理，没学之前处理括号匹配实在是繁杂。
下面是简单的判断回文串。（以前看舍友的代码，有些知识，真的是会过目不忘）

#include<iostream>
#include <stack>
using namespace std;
#define N 100
char str[N];
int main() {
    char c;
    int i=0;
    while(cin>>c) {
        str[i++]=c;
    }
    int n=i;
    bool flag=true;
    for(int i=0,j=n-1;i<=j; i++,j--) {
        if(str[i]!=str[j]) {
            flag=false ;
            break;
        }
    }
    if(flag) {
        cout<<"YES"<<endl;
    } else {
        cout<<"NO"<<endl;
    }
    return 0;
}

3，链表。之前看过谭叔的书。最后一章就是讲得链表，当时也是抄了几遍代码。思维有点混乱。
提到链表就不得不说起指针，指针就是用来存放内存地址的，常用*号表示。
提到链表就不得不说增删改查，于是用于增加的动态申请就出来了。
下面是对*在C/C++中用途的总结：

  1. *用作乘法符号。
  2. *声明一个指针。eg:int *p

  3. *间接运算符（解引用）

    指针的范例

#include<cstdio>
#include <cstdlib>
int main()
{
    int *p;
    p=(int*)malloc(sizeof(int));
    *p=10;
    printf("%d\n",*p);
    return 0;
}

（mallooc函数在stdlib里面，free释放）
嗯，简单来说使用指针的步骤有两步，第一是定义指针变量；第二就是给指针变量填充内容（赋值），值可以是地址&a，也可是*p=a的形式
下面的代码与上一段程序实现相同的内容：

#include <cstdio>
#include <cstdlib>
int main()
{
    int *p;
    int a;
    scanf("%d",&a);
    p=&a;
    printf("%d\n",*p);
    return 0;
}

当然C++中是使用new 来动态动态申请空间，delete进行释放。

#include <iostream>
using namespace std;
int main()
{
    int *p;
    p=new int ;
    *p=10;
    cout<<*p<<endl;
    delete p;
    return 0;
}

下面的程序是一定错误的，禁忌，因为没有申请分配空间，仅仅是定义了一个变量

#include <iostream>
using namespace std;
int main() {
    int *p;
    *p=10;
    cout<<*p<<endl;
    return 0;
}

简单的建立链表

#include <iostream>
#include <cstdlib>
using namespace std;
typedef struct Node { //不要混淆在这里写成*Node，节点类型一般不设为指针
    int data;
    struct Node *next;//自引用，定义了结点的内容。
};
int main() {
    int T;
    Node *p,*q,*head;
    head=NULL;
    cin>>T;
    while(T--) {
        int a;
        cin>>a;
        p=(Node*)malloc(sizeof(Node));
        p->data=a;
        p->next=NULL;
        if(head==NULL) {//这里以前一直不是很懂，终于明白了
            head=p;

        } else {
            q->next=p;
        }
        q=p;
    }
    p=head;
    while(p!=NULL) {
        cout<<p->data<<ends;
        p=p->next;
    }
    cout<<endl;
}

链表添加和删除(排除在第一位添加和删除的情况）

#include <iostream>
#include <cstdlib>
using namespace std;
typedef struct Node { //不要混淆在这里写成*Node，节点类型一般不设为指针
    int data;
    struct Node *next;//自引用，定义了结点的内容。
};
int main() {
    int T;
    Node *p,*q,*head;
    head=NULL;
    cout<<"Please enter the amount of list node:"<<endl;
    cin>>T;
    cout<<"Please enter the list :(ctrl+z to end)"<<endl;
    while(T--) {
        int a;
        cin>>a;
        p=(Node*)malloc(sizeof(Node));
        p->data=a;
        p->next=NULL;
        if(head==NULL) {//这里以前一直不是很懂，终于明白了
            head=p;

        } else {
            q->next=p;
        }
        q=p;
    }
    p=head;
    cout<<"You have created the list:"<<endl;
    while(p!=NULL) {
        cout<<p->data<<ends;
        p=p->next;
    }

    //添加数据
    cout<<"\nPlease enter the number you want to add"<<endl;
    int b;
    cin>>b;
    p=(Node*)malloc(sizeof(Node));
    p->data=b;
    p->next=NULL;
    Node *it;
    it=head;
    while(it!=NULL) {
        if(it->next!=NULL&&it->next->data>b) {//妙，先看看下一项,不过这里好像健壮性不强，要是在第一个位置就要插入怎么办？
            p->next=it->next;
            it->next=p;
            break;//插入结束
        }
        it=it->next;
    }
    cout<<"The new list:"<<endl;
    p=head;
    while(p!=NULL) {
        cout<<p->data<<ends;
        p=p->next;
    }
    cout<<endl;

    //删除数据
    cout<<"Please enter the number which you want to delete :"<<endl;
    cin>>b;
    it=head;
    while(it!=NULL) {
        if(it->next!=NULL&&it->next->data==b) {
            it->next=it->next->next;
            break;
        }
        it=it->next;
    }
    cout<<"The new list:"<<endl;
    p=head;
    while(p!=NULL) {
        cout<<p->data<<ends;
        p=p->next;
    }
    cout<<endl;
    return 0;
}

执行：
这里写图片描述

4，嗯，最后的模拟链表简直是第一次看见，没有多大作用，用一个数组记录数据，再用一个数组记录数据数组右边的数据存在哪一个位置。

飘过的小熊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[啊哈算法]链表
qq_42008588的博客
08-16 190
今天算是对链表和指针有了一个新的感悟。以前总是朦胧的概念，特别对于malloc()函数，几乎是死记硬背，现在认识的清晰了一点。 感触如下： 对于链表的使用正如数组的使用要有常用的遍历符号：t，数组中的遍历符号都是i,j；数组的遍历结束标志为数组长度，链表的遍历结束为t==NULL如果还是有点蒙，请看如下代码： 数组： //数组 for(int i=0;i<n;i++){ ...... ...
第二章 栈、队列、链表.zip
03-03
队列是一种特殊的线性结构，它只允许在队列的首部（head）进行删除操作，这称为“出队”，而在队列的尾部（tail）进行插入操作，这称为“入队”。当队列中没有元素时（即 head==tail），称为空队列。我们称为“先进...
【啊哈算法】栈，队列（简单且详细）
weixin_61034310的博客
12-15 290
友友们，我回来了，众所周知- -程序=算法+数据结构，今天开始我们就进行算法篇的学习。 队列（先进先出）：这是一种特殊的数据结构，它只允许在队列的首部（head）进行删除操作，这称为“出队”，在尾部（tail）进行插入操作，这称为“入队”。当head=tail时成空队列（这为大部分情况下操作完成标识）。 示例： ...
【啊哈！算法】之栈
『程序员·小李』的博客
07-15 298
想要拿到2号球，就得依次取出3号球与1号球。 我们可以使用一个数组和一个栈顶指针实现。 问题引入 判断某个字符串是否是回文。 解决思路 1. 读取字符串，获取字符串长度。 char a[101]; int len; gets(a); len=strlen(a); 2. 获取字符串中点 mid=len/2-1; 3.将中点前的元素入栈 for(...
《啊哈！算法》阅读笔记-----第二章《栈、队列、链表》
Apollo
09-19 534
紧接着上一章的阅读，现在我来自习室开始了第二章（今天下雨了天气很凉爽，太适合学习啦）。那么就一起开始吧~ 第二章—-栈、队列、链表 第一节—-解密qq号—-队列 这本书的引入是很有趣的，就算有时有点烦躁，但看这本书我不会觉得这本书看不下去，真的是很适合我这种懒孩子。那我就直接总结重要知识点，应该会很枯燥的hhhh ………………………………………………………………………………………...
《啊哈,算法》第二章、队列、栈、链表
qq_45467524的博客
11-13 653
二、队列、栈、链表 1、队列 线性结构，先进先出，即只允许在队列的首部（head）进行删除操作，这称为“出队”， 而在队列 的尾部（tail）进行插入操作，这称为“入队”。 先初始化一个数组：int q[10]={0,6,3,1,7,5,8,9,2,4}; 初始化首部，尾部： int head = 1;int tail = 10;，tail初始指向为空，可以避免与head重复； 出队操作：head++； 入队操作：q[tail]=x; tail++；这里x为入队的值 2、栈 线性结构，
数据结构作业：第三章-栈和队列作业答案.docx
12-14
"数据结构作业：第三章-栈和队列作业答案.docx" 本资源摘要信息是关于数据结构第三章栈和队列的作业答案，涵盖了栈和队列的基本概念、操作原则、特点及应用场景。下面是对该资源的详细解读： 1. 栈的操作原则 栈...
线性表、链表、栈、队列.rar
09-11
线性表、链表、栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计和算法实现中有着广泛的应用。以下是对这些概念及其基本操作的详细说明。 线性表是一种基本的一维数据结构，它包含一个有限序列的元素，...
JS常用的数据结构和算法,链表、栈、队列、排序和查找:octocat
最新发布
04-03
在这个主题下，我们将深入探讨四种基本的数据结构——链表、栈、队列以及基础的排序和查找算法。这些概念不仅在日常开发中广泛应用，也是面试中常被考察的知识点。 **链表** 链表是一种线性数据结构，与数组不同，...
数据结构_栈_队列_prim算法_
10-04
综上所述，这些代码示例涵盖了数据结构的基本操作和算法应用，对于学习和理解栈、队列、Prim算法以及链表和二叉树的处理技巧具有很高的价值。掌握这些基础知识对于提升编程能力和解决实际问题至关重要。
【啊哈！算法】栈、队列、链表
博客皆笔记
07-04 268
Contents栈、队列、链表队列 栈、队列、链表 队列 栈 纸牌游戏 小猫钓鱼 链表 模拟链表 队列 队列的三个基本元素：一个数组，两个变量 #include<iostream> using namespace std; struct queue { int data[100]; //队列主体，用来存储内容 int head; //队首 int tail; //队尾 }; typedef struct queue Queue; //将 struct queue
(啊哈！算法）（第二章）链表
肘子的博客
08-03 396
//链表的创建与插入值 #include<iostream> #include<cstdio> #include<cstdlib> using namespace std; struct node{//定义链表节点 int data; struct node *next; }; int main() { struct node *head,*q,...
啊哈算法——第二章：栈队列与链表
fatfairyyy的博客
10-08 138
第二章：栈队列与链表 队列 显然对于队列我们只需要记住它最重要的性质：先进先出（FIFO） 即可。 队列还包括双向队列（deque，用于实现滑动窗口算法），优先队列（priority_queue，用于实现堆）等，在后面的算法内容中会详述。 调用C++STL建立队列：queue<type> q;即建立了一个type类型的队列，名字为q。 栈 对于队列我们只需要记住它最重要的性质：先进后出（FILO） <或后进先出> 即可。 调用C++STL建立队列：stack<type>
《啊哈！算法》学习笔记——栈
李毅飞飞的博客
04-14 360
栈是一种后进先出的数据结构。栈限定为只能在一端进行插入和删除操作。 栈的实现需要一个一维数组和一个指向栈顶的变量top，通过top对栈进行插入和删除操作。 初始化栈将top=0；就可以了，**入栈的操作是top++；s[top]=x；**可以简写为s[++top]=x； 废话不多说，还是看一道例题，来了解一下栈。 例题： 解密回文。“xyzyx”是一个回文字符串，所谓回文字符串就是指正读反读均相同...
【啊哈算法学习笔记】2.栈
爱学习的大白菜的博客
07-01 196
概要： 栈是一种 后进先出 的顺序结构，如可以用于 检测回文串，括号匹配 等。 基本操作： //定义栈 char s[101]; int top //栈初始化 top = 0; //入栈 top++; s[top] = x; /*入栈还可以写成 s[++top] = x */ //出栈 top--; 下面举一个实际的例子： ...
第15周 啊哈算法 栈
时缔&实验室
07-08 547
问题及代码： /*栈:回文检测*/ #include int main() { int a[101],s[101]; int i,top,len,next,mid; gets(a); len=strlen(a); mid=len/2-1; top=0; for(i=0;i<=mid;i++) s[++top]=a[i]; //判断字符串长度
第15周 啊哈算法 链表:用指针链表和数组模拟链表
时缔&实验室
07-09 1303
问题及代码： #include #include struct node { int date; struct node *next; }; int main() { struct node *head,*p,*q,*t; int i,a,n; head=NULL; scanf("%d",&n); for(i=1;i<=n;i
一步一步写算法（之双向链表）
javasee
10-07 176
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 前面的博客我们介绍了单向链表。那么我们今天介绍的双向链表，顾名思义，就是数据本身具备了左边和右边的双向指针。双向链表相比较单向链表，主要有下面几个特点： （1）在数据结构中具有双向指针 （2）插入数据的时候需要考虑前后的方向的操作 （3）同样，删除数据的是有也需要考虑前后方向...
简单易懂数据结构和算法--《啊哈！算法》--栈
m0_46202433的博客
05-05 286
导叙：根据啊哈磊老师的《啊哈！算法》整理的学习笔记，如有侵权，联系删除 图书链接：https://pan.baidu.com/s/18qNteKTnKJJpdo7Dks50FA 提取码：ym1t 关注微信公众“伊斯电子编程”获取更多资源 还有一种是后进先出的数据结构，它叫做栈。栈限定为只能在一端进行插入和删除操作。比如说有一个小桶，小桶的直径只能放一个小球，我们现在小桶内依次放入 2、1、3 号小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值