#include <stdio.h>
#include <stdlib.h>
#define InitMaxsize 3//栈最大可容纳元素个数
typedef int elem;
typedef struct
{
int top[2], bot[2];//定义栈顶和栈底指针
elem *V; //栈数组
int m; //栈最大可容纳元素个数
}DblStack;
//初始化双栈
void InitDblStack(DblStack &stack)
{
elem *arr = (elem*)malloc(sizeof(elem));//申请空间
stack.V = arr; //将V指针指向申请的空间
stack.m = InitMaxsize; //初始化栈最大可容纳最大元素个数
stack.top[0] = -1; //左栈栈顶指针初始化
stack.top[1] = stack.m - 1; //右栈栈顶指针初始化
stack.bot[0] = 0; //左栈栈底指针初始化
stack.bot[1] = stack.m-1; //右栈栈底指针初始化
}
//判断总体是否为空栈
int EmptyDblStack(DblStack stack)
{
if(stack.top[0] == -1 && stack.top[1] == stack.m-1)
return 1; //若是返回1
return 0; //否则返回0
}
//判断左栈是否为空栈
int EmptyLeft(DblStack stack)
{
if(stack.top[0] == -1)
return 1; //若是返回1
return 0; //否则返回0
}
//判断右栈是否为空栈
int EmptyRight(DblStack stack)
{
if(stack.top[1] == stack.m-1)
return 1; //若是返回1
return 0; //否则返回0
}
//判断是否为满栈
int FullDblStack(DblStack stack)
{
if(stack.top[1] == stack.top[0] || stack.top[0] >= stack.m || stack.top[1] < 0 )
//三种满栈情况左右两栈中间相遇,左栈满,右栈满
return 1;//满栈返回1
return 0;//否则返回0
}
//左栈进栈
int pushLeft(DblStack &stack, elem e)
{
if (FullDblStack(stack) == 1)//判断是否为满栈
{
printf("栈已满不能进行进栈操作\n");
return 0; //满栈返回0
}
stack.top[0]++; //左栈栈顶指针加一
stack.V[stack.top[0]] = e; //将数据元素进栈
return 1; //完成操作返回1
}
//右栈进栈
int pushRight(DblStack &stack, elem e)
{
if (FullDblStack(stack) == 1)//判断是否为满栈
{
printf("栈已满,无法进行进栈操作\n");
return 0; //满栈返回0
}
stack.V[stack.top[1]] = e; //将数据元素进栈
stack.top[1]--; //右栈栈顶指针加一
return 1;
}
//左栈出栈
elem popLeft(DblStack &stack)
{
if (EmptyLeft(stack) == 1)//判断是否为空栈
{
printf("左栈已空,无法进行出栈操作\n");
return 0; //空栈返回0
}
elem e = stack.V[stack.top[0]]; //取出栈顶数据元素
stack.top[0]--; //左栈栈顶元素减一
return e; //返回原栈顶元素
}
//右栈出栈
elem popRight(DblStack &stack)
{
if (EmptyRight(stack) == 1) //判断是否为空栈
{
printf("右栈已空,无法进行出栈操作\n");
return 0; //空栈返回0
}
stack.top[1]++; //右栈栈顶指针加一
elem e = stack.V[stack.top[1]]; //取出右栈栈顶元素
return e; //返回原栈顶元素
}
//遍历双栈
void printDblStack(DblStack stack)
{
for (int i = 0; i <= stack.top[0]; i++) //输出左栈
{
printf("|%d| ", stack.V[i]);
}
for(int i = ++stack.top[1]; i < stack.m; i++)//输出右栈
{
printf("|%d| ", stack.V[i]);
}
printf("\n");
}
//调试
int main()
{
DblStack stack;
InitDblStack(stack); //初始化双栈
printf("双栈%s空栈\n", EmptyDblStack(stack) == 1?"是":"不是"); //判断总体是否为空栈
pushLeft(stack, 1); //左栈进栈
pushLeft(stack, 2); //左栈进栈
pushRight(stack, 3); //右栈进栈
printf("双栈%s满栈\n", FullDblStack(stack) == 1?"已":"未");//判断是否为满栈
popLeft(stack);
popRight(stack);
popRight(stack);
printDblStack(stack);
return 0;
}
2.判断回文
s = input('')
if not s:
print('请不要输入空字符串!')
s = input('请重新输入一个字符串:')
a = reversed(list(s))
if list(a) == list(s):
print('是回文')
else:
print('不是回文')
9.Ackermann
package ackermann;
public class Ackermann_2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(ack(4,0));
}
public static int ack(int m, int n) {
int i,j;
int[] val=new int[m+1];
int[] ind=new int[m+1];
for(i=1;i<=m;i++)
{
ind[i]=-1;
val[i]=-1;
}
ind[0]=0;
val[0]=1;
while(ind[m]<n)
{
val[0]++;
ind[0]++;
for(j=1;j<=m;j++)
{
if(1==ind[j-1])
{
val[j]=val[j-1];
ind[j]=0;
}
if(val[j]!=ind[j-1])
break;
ind[j]++;
val[j]=val[j-1];
}
}
return val[m];
}
}
10.链表,最大整数,节点个数
package linkedlist;
import java.util.Stack;
public class SingleLinkedListDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 进行测试
// 先创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(4, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(6, "吴用", "智多星");
HeroNode hero4 = new HeroNode(9, "林冲", "豹子头");
HeroNode hero5 = new HeroNode(2, "宋江", "及时雨");
HeroNode hero6 = new HeroNode(3, "卢俊义", "玉麒麟");
HeroNode hero7 = new HeroNode(5, "吴用", "智多星");
HeroNode hero8 = new HeroNode(8, "林冲", "豹子头");
// 创建一个链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
SingleLinkedList singleLinkedList1 = new SingleLinkedList();
SingleLinkedList singleLinkedList2 = new SingleLinkedList();
// 加入
// singleLinkedList.add(hero1);
// singleLinkedList.add(hero2);
// singleLinkedList.add(hero3);
// singleLinkedList.add(hero4);
// 加入按照编号的顺序
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero4);
singleLinkedList1.addByOrder(hero5);
singleLinkedList1.addByOrder(hero6);
singleLinkedList1.addByOrder(hero7);
singleLinkedList1.addByOrder(hero8);
singleLinkedList.list();
singleLinkedList1.list();
getToget(singleLinkedList.getHead(),singleLinkedList1.getHead(),singleLinkedList2.getHead());
singleLinkedList2.list();
//singleLinkedList.addByOrder(hero1);
//singleLinkedList.list();
//测试单链表的反转功能
// System.out.println("原来链表的情况");
// singleLinkedList.list();
// System.out.println("反转单链表");
// reverseList(singleLinkedList.getHead());
// singleLinkedList.list();
//测试逆序打印
// System.out.println("原来链表的情况");
// singleLinkedList.list();
//
// System.out.println("逆序打印的结果");
// reversePrint(singleLinkedList.getHead());
// //链表本身的结构没有变化
// singleLinkedList.list();
//
// 测试修改节点的代码
// HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
// singleLinkedList.update(newHeroNode);
// 显示
// System.out.println("修改后\n");
// singleLinkedList.list();
// System.out.println("删除第四个");
// singleLinkedList.del(4);
// 测试 求单链表中有效节点的个数
// System.out.println(getLength(singleLinkedList.getHead()));
//测试,看是否得到了倒数第K个节点
// HeroNode res = findLastIndexNode(singleLinkedList.getHead(),4);
// System.out.println(res);
// 显示
//singleLinkedList.list();
}
//5.合并两个有序的单链表,合并之后的链表依然有序
//思路
//对两个链表进行遍历,A,B (两个for循环的嵌套,如果A小于B的就加A,不然break B
public static void getToget(HeroNode head1,HeroNode head2,HeroNode head3){
if(head1.next == null && head2.next == null){
return;
}
if(head1.next == null){
head3.next = head2.next;
}else{
head3.next = head1.next;
HeroNode cur2 = head2.next;
HeroNode cur3 = head3;
HeroNode next = null;
while(cur2 != null){
if(cur3.next == null){
cur3.next = cur2;
break;
}
if(cur2.no<=cur3.next.no){
next = cur2.next;
cur2.next = cur3.next;
cur3.next = cur2;
cur2 = next;
}
cur3 = cur3.next;
}
}
// HeroNode cur1 = head1.next;
// HeroNode cur2 = head2.next;
// while (head1.next!=null){
//
// while(head2.next!=null){
// if(cur1.no>cur2.no){
// toGet.next = cur2.next;
// cur2 = cur2.next;
// }else{
// break;
// }
// }
// toGet.next = cur1.next;
// cur1 = cur1.next;
// }
// return toGet;
}
//4.从尾到头打印单链表(逆序打印单链表)
//思路
//方式1.先将单链表进行反转操作,然后再遍历即可,这样做的问题是会破坏原来的单链表的结构,不建议
//方式2.利用栈这个数据结构,将各个节点压入到栈中,然后利用栈的先进后出的特点,就实现了逆序打印的效果
//利用方式二
public static void reversePrint(HeroNode head){
if (head.next == null){
return ;
}
Stack<HeroNode> stack = new Stack<HeroNode>();
HeroNode cur = head.next;
//将链表的所有节点压入栈中
while(cur!=null){
stack.push(cur);
cur = cur.next;//cur后移,这样就可以压入下一个节点
}
//将栈中的节点进行打印,pop出栈
while(stack.size()>0){
System.out.println(stack.pop());//stack的特点是先进后出
}
}
//3.单链表的反转【腾讯面试题,有难度】
//步骤
//1.先定义一个reverseHead = new HeroNode();
//2.从头到尾遍历原来的链表,每遍历一个节点,将其取出,放到新的链表的最前端
//3.原来的链表的head.next = reverseHead.next
public static void reverseList(HeroNode head){
//如果当前链表为空,或者只有一个节点,无需反转,直接返回
if(head.next == null || head.next.next == null){
return;
}
HeroNode cur= head.next;
HeroNode next = null;
HeroNode reverseHead = new HeroNode(0,"","");
//遍历原来的链表,每遍历一个节点,将其取出,放到新的链表的最前端
while (cur!=null){
next = cur.next;//先暂时保存当前节点的下一个节点,后面要使用
cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
reverseHead.next = cur;//将cur连接到新的链表
cur = next;//让cur后移
}
//将head。next指向reverseHead。next,实现反转
head.next = reverseHead.next;
}
//2.查找单链表的倒数第k个节点【新浪面试题】
//思路
//1. 编写一个方法接收head节点,同时接受一个index
//2.index表示是倒数第index个节点
//3.先把链表从头到尾遍历一下,得到链表的总的长度
//4.得到size后,我们从链表的第一个开始遍历(size-index)个,就可以得到。
//5.如果找到了就返回该节点,否则返回null
public static HeroNode findLastIndexNode(HeroNode head,int index){
//判断 如果链表为空,返回null
if(head.next == null){
return null;//没有找到
}
int size = getLength(head);
//第二次遍历size-length位置,就是我们要找的位置
//先做一个index校验
if(index <= 0||index>size){
return null;
}
//定义一个辅助变量
HeroNode cur = head.next;
for (int i = 0 ; i<(size-index);i++){
cur = cur.next;
}
return cur;
}
// 方法1,获取到单链表的节点的个数(如果是带有头节点的链表,需不统计头节点)
public static int getLength(HeroNode head) {
// head 链表的头节点 返回的就是有效节点的个数
if (head.next == null) {
return 0;
}
int length = 0;
HeroNode cur = head.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
}
// 定义SingleLinkedList管理我们的英雄
class SingleLinkedList {
// 先初始化一个头节点,头节点不要动,不放入具体数据
private HeroNode head = new HeroNode(0, "", "");
// 返回头节点
public HeroNode getHead() {
return head;
}
// 添加节点到单向链表
// 思路当不考虑编号的顺序时
// 1.找到当前链表的最后节点
// 2.将最后这个节点的next指向新的节点
public void add(HeroNode heroNode) {
// 因为head节点不能动,所以需要一个辅助变量
HeroNode temp = head;
// 遍历链表,找到最后
while (true) {
// 找到链表的最后
if (temp.next == null) {
break;
}
// 如果没有找到最后,就将temp后移
temp = temp.next;
}
// 当退出while循环时,temp就指向链表的最后
temp.next = heroNode;
}
// 第二种方式在添加英雄时,根据英雄排名插入到指定位置
// (如果有这个排名则添加失败)
public void addByOrder(HeroNode heroNode) {
// 因为头节点不能动,所以仍需一个辅助指针来帮助找到添加的位置
// 因为单链表,我们找的temp是位于添加位置的前一个节点,否则加不进去
HeroNode temp = head;
boolean flag = false;// 标志添加的编号是否存在,默认为false
while (true) {
if (temp.next == null) {// 说明temp已经在链表的最后
break;
}
if (temp.next.no > heroNode.no) {// 位置找到,将temp的后面插入当前heroNode节点
break;
} else if (temp.next.no == heroNode.no) {// 编号已经存在
flag = true;
break;
}
temp = temp.next;// 后移,遍历当前链表
}
// 判断flag的值
if (flag) {// 不能添加,编号存在
System.out.printf("准备插入的英雄编号%d都已经存在,不能加入\n", heroNode.no);
} else {
// 加入到链表中,temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
// 显示链表【遍历】
public void list() {
// 判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
// 因为头节点不能动,所以需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
// 判断是否到链表最后
if (temp == null) {
break;
}
// 输出这个节点的信息
System.out.println(temp);
// 将temp后移,不然是死循环
temp = temp.next;
}
}
// 修改节点的信息,根据编号来修改,即no编号不能改
// 根据newHeroNode的no来修改
public void update(HeroNode newHeroNode) {
// 判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
// 找到需要修改的节点,根据no编号
HeroNode temp = head.next;
boolean flag = false;// 表示是否找到该节点
while (true) {
if (temp == null) {
break;// 到链表的最后,已经遍历完链表了
}
if (temp.no == newHeroNode.no) {
flag = true;
break;
}
temp = temp.next;
}
// 根据flag判断是否找到要修改的节点
if (flag) {
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
} else {// 没有找到
System.out.printf("没有找到编号%d的节点,不能修改\n", newHeroNode.no);
}
}
// 删除一个节点
public void del(int no) {
// 判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
// 找到需要删除的节点
HeroNode temp = head;
boolean flag = false;
while (true) {
if (temp.next == null) {
System.out.println("没有所要删除的节点");
break;
}
if (temp.next.no == no) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
// HeroNode dhero = temp.next;
temp.next = temp.next.next;
} else {
System.out.println("没有找到");
}
}
}
// 先定义一个heroNode,每个HeroNode对象就是一个节点
class HeroNode {
public int no;
public String name;
public String nickname;
public HeroNode next;// 指向下一个节点
public HeroNode(int hNo, String hName, String hNickname) {
this.no = hNo;
this.name = hName;
this.nickname = hNickname;
}
// 为了显示方法,我们重写toString
@Override
public String toString() {
return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
}
}