第三章 栈和队列 算法题

#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 + "]";
	}

}