啊哈1

排序

最快最简单的排序——桶排序
期末考试完了老师要将同学们的分数按照从高到低排序。小哼的班上只有 5 个同学，这 5 个同学分别考了 5 分、3 分、5 分、2 分和 8 分，哎考得真是惨不忍睹（满分是 10 分）。接下来将分数进行从大到小排序，排序后是 8 5 5 3 2。
O(m+n+m+n)== O(2*(m+n))==O(M+N)

#include <stdio.h>
int main()
{
	int book[1001],i,j,t,n;
	for(i=0;i<=1000;i++)
		book[i]=0;
	scanf("%d",&n);//输入一个数n，表示接下来有n个数
	for(i=1;i<=n;i++)//循环读入n个数，并进行桶排序
	{
		scanf("%d",&t); //把每一个数读到变量t中
		book[t]++; //进行计数，对编号为t的桶放一个小旗子
	}
	for(i=1000;i>=0;i--) //依次判断编号1000~0的桶
		for(j=1;j<=book[i];j++) //出现了几次就将桶的编号打印几次
			printf("%d ",i);
	getchar();getchar();
return 0;
}

邻居好说话——冒泡排序
越小的越靠后

#include<bits/stdc++.h>
using namespace std;

int main(){
	int a[100],t,n;
	scanf("%d",&n);  //输入一个数n，表示接下来有n个数
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	} 
	//冒泡排序的核心部分
	for(int i=1;i<=n-1;i++){  //n个数排序，只用进行n-1趟 
		for(int j=1;j<=n-i;j++){  //从第1位开始比较直到最后一个尚未归位的数，到n-1就可以了
			if(a[j]<a[j+1]){ //比较大小并交换 
				t=a[j];
				a[j]=a[j+1];
				a[j+1]=t; 
			} 
		}
	} 
	for(int i=1;i<=n;i++){ //输出结果 
		printf("%d ",a[i]); 
	}
	getchar();getchar();
	return 0; 
} 

#include<bits/stdc++.h>
using namespace std;

struct student{
	char name[21];
	char score;
};//这里创建了一个结构体用来 

int main(){
	struct student a[100],t;
	int n;
	scanf("%d",&n);  
	for(int i=1;i<=n;i++){
		scanf("%s %d",&a[i].name,&a[i].score);
	} 

	for(int i=1;i<=n-1;i++){ 
		for(int j=1;j<=n-i;j++){  
			if(a[j].score<a[j+1].score){
				t=a[j];
				a[j]=a[j+1];
				a[j+1]=t; 
			} 
		}
	} 
	for(int i=1;i<=n;i++){ //输出结果 
		printf("%s\n",a[i].name); 
	}
	getchar();getchar();
	return 0; 
} 

最常用的排序——快速排序

#include<bits/stdc++.h>
using namespace std;

int a[101],n; //定义全局变量，这两个变量需要在子函数中使用 

void quicksort(int left,int right){
	int i,j,t,temp;
	if(left>right)return;
	
	temp=a[left]; //temp中存的就是基准数
	i=left;
	j=right;
	while(i!=j){
		//顺序很重要，要先从右往左找
		while(a[j]>=temp && i<j){
			j--;
		} 
		//再从左往右找
		while(a[i]<=temp && i<j){
			i++;
		} 
		//交换两个数在数组中的位置
		if(i<j){ //当哨兵i和哨兵j没有相遇时
			t=a[i];
			a[i]=a[j];
			a[j]=t; 
		} 
	} 
	//最终将基准数归位
	a[left]=a[i];
	a[i]=temp;
	
	quicksort(left,i-1);  //继续处理左边的，这里是一个递归的过程 
	quicksort(i+1,right); //继续处理右边的，这里是一个递归的过程 
}

int main(){
	int i,j,t;
	//读入数据 
	scanf("%d",&n);  
	for(i=1;i<=n;i++){
		scanf("%d",&a[i]);
	} 

	quicksort(1,n); //快速排序调用 

	//输出排序后的结果 
	for(i=1;i<=n;i++){ //输出结果 
		printf("%d ",a[i]); 
	}
	getchar();getchar();
	return 0; 
} 

小哼买书
先将这 n 个图书的 ISBN号去重，再进行从小到大排序并输出
桶排序稍加改动正好可以起到去重的效果，因此我们可以使用桶排序的方法来解决此问题。
O(N+M)

#include <stdio.h>
int main()
{
	int a[1001],n,i,t;
	for(i=1;i<=1000;i++){
		a[i]=0; //初始化
	}
	
	scanf("%d",&n); //读入n
	
	for(i=1;i<=n;i++) //循环读入n个图书的ISBN号
	{
		scanf("%d",&t); //把每一个ISBN号读到变量t中
		a[t]=1; //标记出现过的ISBN号
	}
	for(i=1;i<=1000;i++) //依次判断1~1000这个1000个桶
	{
		if(a[i]==1)//如果这个ISBN号出现过则打印出来
		printf("%d ",i);
	}
	getchar();getchar();
	return 0;
}

1.先从小到大排序，输出的时候再去重。排序我们可以用冒泡排序或者快速排序
因为我们已经排好序，所以相同的数都会紧挨在一起。只要在输出的时候，预先判断一下当前这个数 a[i]与前面一个数 a[i1]是否相同。如果相同则表示这个数之前已经输出过了，不用再次输出；不同则表示这个数是第一次出现，需要输出这个数
2. 这种方法的时间复杂度由两部分组成，一部分是冒泡排序的时间复杂度，是 N (N 2 )，另一部分是读入和输出，都是 O(N)，因此整个算法的时间复杂度是 O(2N+N 2 )。相对于 N 2 来说，2N 可以忽略（我们通常忽略低阶），最终该方法的时间复杂度是 O(N 2 )。

#include <stdio.h>
int main()
{
	int a[101],n,i,j,t;
	scanf("%d",&n); //读入n
	for(i=1;i<=n;i++) //循环读入n个图书ISBN号
	{
		scanf("%d",&a[i]);
	}
	//开始冒泡排序
	for(i=1;i<=n-1;i++)
	{
		for(j=1;j<=n-i;j++)
		{
			if(a[j]>a[j+1])
			{ t=a[j]; a[j]=a[j+1]; a[j+1]=t; }
		}
	}
	printf("%d ",a[1]); //输出第1个数
	for(i=2;i<=n;i++) //从2循环到n
	{
		if( a[i] != a[i-1] ) //如果当前这个数是第一次出现则输出
		printf("%d ",a[i]);
	}
	getchar();getchar();
	return 0;
}

栈、队列、链表

第 1 节 解密 QQ 号——队列

首先将第 1个数删除，紧接着将第 2 个数放到这串数的末尾，再将第 3 个数删除并将第 4 个数放到这串数的末尾，再将第 5个数删除……直到剩下最后一个数，将最后一个数也删除。按照刚才删除的顺序，把这些删除的数连在一起就是小哈的 QQ啦

首先需要一个数组来存储这一串数即 int q[101]，并初始化这个数组即 int q[101]=
{0,6,3,1,7,5,8,9,2,4};（此处初始化是我多写了一个 0，用来填充 q[0]，因为我比较喜欢从 q[1]开始用

引入两个整型变量 head 和 tail。head 用来记录队列的队首（即第一位）， tail 用来记录队列的队尾（即最后一位）的下一个位置
(因为当队列中只剩下一个元素时，队首和队尾重合会带来一些麻烦。我们这里规定队首和队尾重合时，队列为空。)

在队首删除一个数的操作是 head++; 在队尾增加一个数（假设这个数是 x）的操作是 q[tail]=x;tail++

#include <stdio.h>
int main()
{
	int q[102]={0,6,3,1,7,5,8,9,2,4},head,tail;
	int i;
	//初始化队列
	head=1;
	tail=10;//队列中已经有9个元素了，tail指向队尾的后一个位置
	while(head<tail){ //当队列不为空的时候执行循环 
		//打印队首并将队首出列
		printf("%d ",q[head]);//6
		head++; //head=2
		
		//先将新队首的数添加到队尾
		q[tail]=q[head];//3存到队尾 
		tail++;  //尾 =11 
		//再将队首出队
		head++; 
	} 
}
//6 1 5 9 4 7 2 8 3 

#include<bits/stdc++.h>
using namespace std;

struct queue{
	int data[100];//队列的主体，用来存储内容
	int head;
	int tail; 
};

int main(){
	struct queue q;
	int i;
	q.head=1;
	q.tail=1;
	
	for(i=1;i<=9;i++){  //依次向队列插入9个数 
		scanf("%d",&q.data[q.tail]);
		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; 
} 

STL模板类_队列
头文件 queue<typename> name;
1.queue 容器中的元素访问
  在STL中只能通过 front() 来访问队首元素，或是通过 back() 来访问队尾元素。
2.常用方法
1）push()
  push(x) 将 x 进行入队
2）front()、back()
3）pop()
  令队首元素出队
4）empty()
  检测 queue 是否为空，返回 true 则空，返回 false 则非空
5）size()
  返回 queue 内元素个数。

使用STL的 queue 时，元素入队的 push 操作只是制造了该元素的一个副本入队，因此在入队后对原元素的修改不会影响队列中的副本，而对队列中的副本修改也不会改变原元素。
原文链接

第2节 解密回文——栈

//12321 //abcba // ( * & * (

后进先出，“xyzyx”是一个回文字符串，所谓回文字符串就是指正读反读均相同的字符序列，判断一个字符串是否为回文
1，首先我们需要读取这行字符串，并求出这个字符串的长度
char a[101]; int len=strlen(a);
2，如果一个字符串是回文的话，那么它必须是中间对称的，我们需要求中点
mid=len/2-1;
3.我们先将 mid 之前的字符全部入栈。因为这里的栈是用来存储字符的，所以这里用来实现栈的数组类型是字符数组即 char s[101];，初始化栈很简单，top=0;就可以了。入栈的操作是top++; s[top]=x; （假设需要入栈的字符暂存在字符变量x中），其实可以简写为s[++top]=x;。
for(i=0;i<=mid;i++){ s[++top]=a[i]; }
将当前栈中的字符依次出栈，看看是否能与 mid 之后的字符一一匹配

for(i=mid+1;i<=len-1;i++){
	if (a[i]!=s[top])break;
	top--;
}
if(top==0)
	printf("YES");
else
	printf("NO");

完整代码

#include <stdio.h>
#include <string.h>
int main()
{
	char a[101],s[101];
	int i,len,mid,next,top;
	scanf("%s",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-1;i++){
		if(a[i]!=s[top])break;
		top--;
	}
	//如果top的值为0，则说明栈内所有的字符都被一一匹配了
	if(top==0)
		printf("YES");
	else
		printf("NO");
	getchar();getchar();
	return 0;	
}

第3节 纸牌游戏——小猫钓鱼
将一副扑克牌平均分成两份，每人拿一份。小哼先拿出手中的第一张扑克牌放在桌上，然后小哈也拿出手中的第一张扑克牌，并放在小哼刚打出的扑克牌的上面，就像这样两人交替出牌。出牌时，如果某人打出的牌与桌上某张牌的牌面相同，即可将两张相同的牌及其中间所夹的牌全部取走，并依次放到自己手中牌的末尾。【当任意一人手中的牌全部出完时】，游戏结束，对手获胜。
小哼： 2 4 1 2 5 6，小哈：3 1 3 5 6 4，最终谁会获胜呢？
小哼和小哈手中牌的牌面只有 1~9。
分析操作：
【队列】：出牌和赢牌。出牌就是出队，赢牌就是入队。
【栈】：桌子，每打出一张牌放到桌上就相当于入栈。当有人赢牌的时候，依次将牌从桌上拿走，这就相当于出栈。
赢牌规则
如果某人打出的牌与桌上的某张牌相同，即可将两张牌以及中间所夹的牌全部取走。
法一：枚举，找有没有相同的。
法二：book,如果桌面上增加了一张牌面为 2 的牌，那就需要将 book[2]设置为 1，表示牌面为 2 的牌桌上已经有了。当然如果这张牌面为 2 的牌被拿走后，需要及时将 book[2]重新设置为 0，表示桌面上已经没有牌面为 2 的牌了

#include <stdio.h>
struct queue   //队列 
{
	int data[1000];
	int head;
	int tail;
};
struct stack   //栈 
{
	int data[10]; //因为只有 9 种不同牌面 
	int top;
};
int main()
{
	struct queue q1,q2;
	struct stack s;
	int book[10];
	int i,t;
//------------------准备------------------------------
	//初始化队列
	q1.head=1; q1.tail=1;
	q2.head=1; q2.tail=1;
	//初始化栈
	s.top=0;
	//初始化用来标记的数组，用来标记哪些牌已经在桌上
	for(i=1;i<=9;i++)
		book[i]=0;
	//依次向队列插入6个数
	//小哼手上的6张牌
	for(i=1;i<=6;i++)
	{
		scanf("%d",&q1.data[q1.tail]);
		q1.tail++;
	}
	//小哈手上的6张牌
	for(i=1;i<=6;i++)
	{
		scanf("%d",&q2.data[q2.tail]);
		q2.tail++;
	}
	
//------------------游戏开始------------------------------
	while(q1.head<q1.tail && q2.head<q2.tail ) //当队列不为空的时候执行循环
	{
		t=q1.data[q1.head];//小哼出一张牌
		//判断小哼当前打出的牌是否能赢牌
		if(book[t]==0) //表明桌上没有牌面为t的牌
		{
			//小哼此轮没有赢牌
			q1.head++; //小哼已经打出一张牌，所以要把打出的牌出队
			s.top++;
			s.data[s.top]=t; //再把打出的牌放到桌上，即入栈
			book[t]=1; //标记桌上现在已经有牌面为t的牌
		}
		else
		{
			//小哼此轮可以赢牌
			q1.head++;//小哼已经打出一张牌，所以要把打出的牌出队
			q1.data[q1.tail]=t;//紧接着把打出的牌放到手中牌的末尾
			q1.tail++;
			while(s.data[s.top]!=t) //把桌上可以赢得的牌依次放到手中牌的末尾
			{
				book[s.data[s.top]]=0;//取消标记
				q1.data[q1.tail]=s.data[s.top];//依次放入队尾
				q1.tail++;
				s.top--; //栈中少了一张牌，所以栈顶要减1
			}
		}	
		t=q2.data[q2.head]; //小哈出一张牌
		//判断小哈当前打出的牌是否能赢牌
		if(book[t]==0) //表明桌上没有牌面为t的牌
		{
			//小哈此轮没有赢牌
			q2.head++; //小哈已经打出一张牌，所以要把打出的牌出队
			s.top++;
			s.data[s.top]=t; //再把打出的牌放到桌上，即入栈
			book[t]=1; //标记桌上现在已经有牌面为t的牌
		}
		else
		{
			//小哈此轮可以赢牌
			q2.head++;//小哈已经打出一张牌，所以要把打出的牌出队
			q2.data[q2.tail]=t;//紧接着把打出的牌放到手中牌的末尾
			q2.tail++;
			while(s.data[s.top]!=t) //把桌上可以赢得的牌依次放到手中牌的末尾
			{
				book[s.data[s.top]]=0;//取消标记
				q2.data[q2.tail]=s.data[s.top];//依次放入队尾
				q2.tail++;
				s.top--;
			}
		}
	}


	if(q2.head==q2.tail)
	{
		printf("小哼win\n");
		printf("小哼当前手中的牌是");
		for(i=q1.head;i<=q1.tail-1;i++)
			printf(" %d",q1.data[i]);
		if(s.top>0) //如果桌上有牌则依次输出桌上的牌
		{
			printf("\n桌上的牌是");
			for(i=1;i<=s.top;i++)
				printf(" %d",s.data[i]);
		}
		else
			printf("\n桌上已经没有牌了");
	}
	else
	{
		printf("小哈win\n");
		printf("小哈当前手中的牌是");
		for(i=q2.head;i<=q2.tail-1;i++)
			printf(" %d",q2.data[i]);
		if(s.top>0) //如果桌上有牌则依次输出桌上的牌
		{
			printf("\n桌上的牌是");
			for(i=1;i<=s.top;i++)
				printf(" %d",s.data[i]);
		}
		else	
			printf("\n桌上已经没有牌了");
	}
	getchar();getchar();
	return 0;
}

第4节 链表
方便插入
动态存储指针：

//输入：
//9
//2 3 5 8 9 10 18 26 32
//输出：
//2 3 5 8 9 10 18 26 32
#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=1;i<=n;i++)//循环读入n个数
	{
		scanf("%d",&a);
		//动态申请一个空间，用来存放一个结点，并用临时指针p指向这个结点
		p=(struct node *)malloc(sizeof(struct node));
		p->data=a;//将数据存储到当前结点的data域中
		p->next=NULL;//设置当前结点的后继指针指向空，也就是当前结点的下一个结点为空
		if(head==NULL)
			head=p;//如果这是第一个创建的结点，则将头指针指向这个结点
		else
			q->next=p;//如果不是第一个创建的结点，则将上一个结点的后继指针指向当前结点
		q=p;//指针q也指向当前结点
	}
	//输出链表中的所有数
	t=head;
	while(t!=NULL)
	{
		printf("%d ",t->data);
		t=t->next;//继续下一个结点
	}
	getchar();getchar();
	return 0;
}

插入

#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=1;i<=n;i++)//循环读入n个数
	{
		scanf("%d",&a);
		//动态申请一个空间，用来存放一个结点，并用临时指针p指向这个结点
		p=(struct node *)malloc(sizeof(struct node));
		p->data=a;//将数据存储到当前结点的data域中
		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->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;
}

第五节 模拟链表

#include<stdio.h>
int main(){
	int data[101],right[101];
	int i,n,t,len;
	//读入已有的数data
	scanf("%d",&n);
	for(i=1;i<=n;i++){
		scanf("%d",&data[i]);
	} 
	len=n;
	//初始化数组right
	for(i=1;i<=n;i++){
		if(i!=n){
			right[i]=i+1;
		}
		else{
			right[i]=0;
		}
	}
	
	//直接在数组data的末尾增加一个数
	len++;
	scanf("%d",&data[len]);
	
	//从链表的头部开始遍历
	t=1;
	while(t!=0){
		if(data[right[t]]>data[len]) 
		//如果当前结点下一个结点的值大于待插入数，将数插入到中间 
		{
			right[len]=right[t];//新插入数的下一个结点标号等于当前结点的下一个结点编号 
			right[t]=len; //当前结点的下一个结点编号就是新插入数的编号 
			break; //插入完成跳出循环 
		} 
		t=right[t]; 
	} 
	//输出链表中所有的数
	t=1;
	while(t!=0){
		printf("%d ",data[t]);
		t=right[t];
	} 
	getchar();
	getchar();
	return 0;
}
//输入 
//9
//2 3 5 8 9 10 18 26 32
//6
//输出 
//2 3 5 6 8 9 10 18 26 32

模拟链表也可以实现双向链表和循环链表