一、队列
【问题】
请解密以下数字：6 3 1 7 5 8 9 2 4。解密规则为：首先将第一个数删除，紧接着将第二个数放到这串数的末尾，再将第三个数删除并将第四个数放到这串数的末尾，再将第五个数删除…直到剩下最后一个数，将最后一个数也删除。按照刚才的删除顺序，把这串数连在一起。
【引入队列概念】
百度百科解释队列：队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。
队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。
【解析】
解密过程就像把这些数排队。每次从最前面拿出两个，第一个删掉，第二个排在后面。具体过程是这样的：对于“6 3 1 7 5 8 9 2 4”，首先删除6并将3放到后面，这串数更新为“1 7 5 8 9 2 4 3”。接下来删除1并将7放到后面，即更新为“5 8 9 2 4 3 7”.再删除5并将8放到后面，更新为“9 2 4 3 7 8”，删除9将2移到后面，更新为“4 3 7 8 2”，删除4并将3放到末尾即“7 8 2 3”，删除7并将8放到末尾即“2 3 8”，删除2并将3放到末尾即“8 3”，删除8并将3放到末尾即“3”，删除3.因此被删除的顺序为“6 1 5 9 4 7 2 8 3”。这种在一段删除再另一端删除的做法很符合队列的操作规则，所以可以用队列来解决这个问题。
【解法】
首先需要一个整型数组来存储这些数即int q[100],并初始化这个数组int q[100]={6,3,1,7,5,8,9,2,4};同时我们引入两个整型数据head和tail。head用来记录队列的队首，即第一位，tail用来记录队尾的下一个位置。这是因为当队列只剩下一个元素时，队首和队尾重合会带来一些麻烦。我们规定队首和队尾重合时，队列为空。
现在有九个数，全部放入队列后，head=0，tail=9。如果要删除一个数，就将head++就可以了，如果需要增加一个数，就将tail++就可以了。head和tail之间的数就是目前队列里的数。
【c语言实现】
#include<stdio.h>
int main()
{
int q[100]={6,3,1,7,5,8,9,2,4},head,tail;
//初始化队列
head=0;
tail=9;
while(head<tail)
{
//打印队首并将队首出队
printf("%d ",q[head]);
head++;
//先将新队首的数添加到队尾
q[tail]=q[head];
tail++;
//再将队首出队
head++;
}
getchar();getchar();
return 0;
}
###将队列封装成一个结构体
【c语言实现如下】
#include<stdio.h>
struct queue
{
int data[100]; //队列的主体
int head; //队首
int tail; //队尾
};
int main()
{
struct queue q;
int i,n;
//初始化队列
q.head=0;
q.tail=0;
scanf("%d",&n); //数据的个数
for(i=0;i<n;i++)
{
scanf("%d",&q.data[i]);
q.tail++;
}
while(q.head<q.tail)
{
//打印队首并将队首出队
printf("%d ",q.data[q.head]);
q.head++;
//先将新队首的数添加到队尾
q.data[q.tail]=q.data[q.head];
q.tail++;
//再将队首出队
q.head++;
}
getchar();getchar();
return 0;
}
队列写起来非常冗余，但是这样写可以加强你对队列的理解。C++的STL库已经有队列的实现，用起来很方便。
【Java语言实现】
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class LQueue {
static Queue<Integer> q=new LinkedList<Integer>();
static Scanner sc=new Scanner(System.in);
public static void main(String[] args) {
int n=sc.nextInt();
for(int i=0;i<n;i++)
q.offer(sc.nextInt());
while(q.peek() != null) {
System.out.print(q.poll()+" ");
if(q.peek()==null)
break;
q.offer(q.peek());
q.poll();
}
}
}
因为Java语言已经有了对队列的实现，这个选择直接使用，不再赘述。
二、栈
【问题】
判断一字符串是不是回文字符串，所谓回文字符串，就是正读反读均相同的字符串，如“xyzyx”,“席主席”，“abcba”均是回文字符串。
【引入栈概念】
百度百科解释：栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
维基百科解释：堆栈（英语：stack）又称为栈或堆叠，是计算机科学中的一种抽象数据类型，只允许在有序的线性数据集合的一端（称为堆栈顶端，英语：top）进行加入数据（英语：push）和移除数据（英语：pop）的运算。因而按照后进先出（LIFO, Last In First Out）的原理运作。
【解析】
如果一个字符串是回文的话，那么它必须是中间对称的，我们需要求中点。
对于任意字符串，如果它的中点前的部分与中点后的部分可以完全重合，则可以判断该字符串为回文字符串。
【解法】
我们先将中点前的字符全部入栈。因为这里的栈是用来存储字符的，所以这里用来实现栈的数组类型为字符串数组即char s[100]；，初始化栈很简单，top=0；（一般情况下初始化栈是让top=-1;，但是我们这个引文从s[1]开始存储数据，所以初始化为top=0;）就可以了。入栈的的操作是top++；s[top]=x;（假设需要入栈的字符暂存在字符变量x中），其实可以简写为s[++top]=x;。
接下来进入判断回文的关键步骤。将当前栈中的字符依次出栈，看看是否能与中点后的字符一一匹配，如果能匹配则说明这个字符串是回文字符串，否则这个字符串不是回文字符串。
【c语言实现】
#include<stdio.h>
#include<string.h>
int main()
{
char a[100],s[100];
int i,len,mid,next,top;
gets(a); //读入一行字符串
len=strlen(a); //求字符串的长度
mid=len/2-1; //求字符串的中点
top=0; //栈的初始化
//将mid前的字符依次入栈
for(i=0;i<=mid;i++)
s[++top]=a[i];
//判断字符串的长度是奇数还是偶数，并找出需要进行字符匹配的起始下标
if(len%2==0)
next=mid+1;
else
next=mid+2;
//开始匹配
for(i=next;i<len;i++)
{
if(a[i]!=s[top])
break;
top--;
}
//如果top的值为0，则说明栈内所有的字符都被一一匹配了
if(top==0)
printf("YES");
else
printf("NO");
getchar();getchar();
return 0;
}
【Java语言实现】
import java.util.Scanner;
public class LStack {
static Scanner sc=new Scanner(System.in);
public static void main(String[] args) {
char s[]=new char[100];
int i,len,mid,next,top;
String a=new String(sc.nextLine());
len=a.length();
mid=len/2-1;
top=0;
for(i=0;i<=mid;i++)
s[++top]=a.charAt(i);
if(len%2==0)
next=mid+1;
else
next=mid+2;
for(i=next;i<len;i++) {
if(a.charAt(i)!=s[top])
break;
top--;
}
if(top==0)
System.out.println("YES");
else
System.out.println("NO");
}
}
【其他应用】
栈还可以用来进行验证括号的匹配。在编程中我们会遇到三种括号：圆括号（），方括号[ ]和花括号{ }，编译器在编译的时候会检查括号是否匹配正确。例如{（[]）}、{（）{}[]}都是合法的匹配。但是{（）]则是不合法的匹配。
【注意】
栈的操作还有很多，比如出栈，入栈，取栈顶元素，判断栈是否为空，判断是否栈满，主要思路都是操作top的值，或者判断top的值。
三、链表
【问题】
存储数据的时候，我们大多数情况下都会使用数组，数组很方便也很简单。但是对于一些特定操作，数组就显得不是很灵活。比如，对于给定的一串排序好的数字：2 3 5 8 9 10 18 26 32。现需要将数字6插在其中，且顺序仍要求从小到大排序。如果我们用数组来操作的话，则需要将8及其8以后的所有数字都依次向后挪一位。这样的操作就显得很麻烦也很浪费时间，这时如果选择链表就快得多。
【引入链表概念】
百度百科解释及比较：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
链表的每一个结点都由两部分组成。一个是存储的数据的数据域，另一个是存储下一个结点地址的指针域。这里我们可以定义一个结构体类型来存储这个结点，如下：
struct node
{
int data;
struct node *next;
};
如何建立链表呢？首先我们需要一个头指针head指向链表的最开始。当链表还没有建立的时候头指针为空（也可以理解为头指针指向空结点）。
struct node *head;
head=NULL; //头指针初始为空
现在我们来创建第一个结点，并用临时指针p指向这个结点。
struct node *p;
//动态申请一个空间，用来存放一个结点，并用临时结点指针p指向这个结点
p=(struct node*)malloc(sizeof(struct node));
接下来分别设置新创建的这个结点的数据域和指针域。
scanf("%d",&a);
p->data=a;//将数据存储到当前结点的数据域中
p->next=NULL;//设置当前结点的后继指针为空，也就是当前结点的下一个结点为空
下面来设置头指针并设置新创建结点的*next指向空。头指针的作用是方便以后从头到尾遍历整个链表。
if(head==NULL)
head=p;//如果这是第一个创建的结点，则将指针指向这个结点
else
q->next=p;//如果这个不是第一个创建的结点，则将上一个结点的后继指针指向当前节点
完整代码如下：
【c语言实现】
#include<stdio.h>
#include<stdlib.h>
//这里创建一个结构体用来表示链表的结点类型
struct node
{
int data;
struct node *next;
};
int main()
{
struct node *head,*p,*q,*t;
int i,n,a;
scanf("%d",&n);
head=NULL;//头指针初始为空
for(i=0;i<n;i++)//循环读入n个数
{
scanf("%d",&a);
//动态申请一个空间，用来存放一个结点，并用临时指针p指向这个结点
p=(struct node *)malloc(sizeof(struct node));
p->data=a;//将数据存储到当前结点的数据域中
p->next=NULL;//设置当前结点的后继指针指向空，也就是当前结点的下一个结点为空
if(head==NULL)
head=p;//如果这是第一个创建的结点，则将头指针指向这个结点
else
q->next=p;//如果不是第一个创建的结点，则将上一个结点的后继指针指向当前结点
q=p;//指针q也指向当前结点
}
scanf("%d",&a);//读入待插入的数
t=head;//从链表的头部开始遍历
while(t!=NULL)//当没有到达链表的尾部的时候循环
{
if(t->next==NULL||t->next->data>a)
//如果当前结点是最后一个结点或者下一个结点的值大于待插入的数的时候插入
{
p=(struct node *)malloc(sizeof(struct node));//动态申请一个空间，用来存放新增结点
p->data=a;
p->next=t->next;//新增结点的后继指针指向当前结点的后继指针所指向的结点
t->next=p;//当前结点的后继指针指向新增结点
break;//插入完毕结束循环
}
t=t->next;//继续下一个结点
}
//输出链表中的所有数
t=head;
while(t!=NULL)
{
printf("%d ",t->data);
t=t->next;//继续下一个数
}
getchar();getchar();
return 0;
}
【Java语言实现】
import java.util.Scanner;
class Node{
int data;
Node next=null;
public Node(int data){
this.data=data;
}
}
public class Main {
public static void main(String[] args) {
Node head=null,p=null,q=null,t=null;
int i,n,a;
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
for(i=0;i<n;i++)
{
p=new Node(sc.nextInt());
p.next=null;
if(head==null)
head=p;
else
q.next=p;
q=p;
}
a=sc.nextInt();
t=head;
while(t!=null)
{
if(t.next==null||t.next.data>a)
{
p=new Node(a);
p.next=t.next;
t.next=p;
break;
}
t=t.next;
}
t=head;
while(t!=null)
{
System.out.print(t.data+" ");
t=t.next;
}
}
}
【写在后面】
其实，不论是栈还是队列 ，都有其链表实现，只不过因为数组方便简单，所以本人都喜欢同数组来表示栈和队列，不过两种实现方式各有各的优点。
四、模拟链表
如果你很讨厌指针，那么链表还有一种不需要指针的实现方法，我们称为模拟链表。
链表中的每个结点只有两个部分。我们可以用一个数组data来存储每序列中的每一个数。再用另一个数组right来存放序列中每一个数的下一个数是谁就可以了。
【具体实现】
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
