栈 数组

#include <iostream>
using namespace std;

typedef int T;

class Stack{
	T a[10];	
	int num;	//记录已经放入的元素个数 
public:
	void push(const T& t)
	{
		if (full())
			throw "stack overflow";
		a[num++] = t;		
	}
	void pop()
	{
		if (empty())
			throw "empty stack";
		num--;	
	}
	T top()
	{
		if (empty())
			throw "no top stack";
		return a[num-1];
	}
 	bool empty()
 	{
	 	return num == 0;	
    }
    bool full()
    {
    	return num == 10;	
    }
	int size()
	{
		return num;	
	} 
	int capacity()
	{
		return 10;
	}
	void clear()
	{
		num = 0;
	}
	Stack():num(0)
	{
		
	}
};

int main()
{
	Stack s;
	s.push(1);
	s.push(2);
	s.push(3);
	/*
	for (int i=0; i<10; i++)
	{
		s.push(i*5);
	}
	*/
	while(!s.empty())
	{
		cout << s.top() << ' ';
		s.pop();
	}
	cout << endl;
/*	for (int i=0; i<10; i++)
		s.push(i);
	cout << "full?" << s.full() << endl;
	s.push(100); //there is  an exception
	cout << "cant see this" << endl;
*/
}

<think>嗯,这个问题是关于双结构的操作实现。让我仔细看看题目要求。题目中说有两个,编号0和1,存放在一个数组V[m]里。底分别在数组的两端,0的底在左边,1的在右边。两个向中间增长。需要实现初始化、判断空、满、进和出的函数。数据结构已经给出,包括top数组、bot数组,以及数组V和最大容量m。 首先,我需要明确每个操作的逻辑。初始化的话,应该设置两个顶指针。根据题目,当0为空时,top[0]是-1,而1为空时top[1]等于m。那初始化的时候,应该把top[0]设为-1,top[1]设为m。bot数组可能用来记录底的位置,但题目中底是固定的,可能bot[0]=0,bot[1]=m-1?或者可能初始时bot的设置与top相同?需要再仔细看题目。题目里说,底分别处于数组的两端。数组是V[m],所以索引应该是0到m-1。0的底在0的位置,1的底在m-1的位置?比如,0的初始top是-1,当压入元素时,top[0]增加到0,然后继续向中间增长。1的初始top是m,当压入元素时,top[1]减少到m-1,然后继续向中间减少。所以bot数组可能记录各自的底位置,但底是固定的,初始时bot[0]=0,bot[1]=m-1?或者是不是bot数组可能不需要,因为底的位置是固定的?不过数据结构定义里包含了bot数组,所以必须使用它。可能初始化的时候,bot[0]设为-1,或者0?或者根据题目描述,0的底在数组左端,也就是索引0的位置,而1的底在数组右端,即m-1的位置。那bot数组应该保存各自的底位置,即bot[0]=0,bot[1]=m-1?或者可能bot数组可能被用来动态变化?可能这里需要重新理解结构定义。 结构体中的top和bot数组可能分别存储两个顶和底指针。对于双结构,0的底应该固定在数组的起始位置,即索引0处,而1的底固定在数组末尾,即索引m-1处。而top[0]从-1开始增长,top[1]从m开始减少。当0有元素时,top[0]递增,1的top[1]递减。判断满的条件应该是两个顶相遇或者交叉,即top[0] +1 >= top[1]。 那初始化函数需要为DblStack结构分配空间,设置top数组的初始值。比如,top[0] = -1,top[1] = m。而bot数组可能记录的是底的位置,这里0的底是0,1的是m-1?或者bot数组可能初始化为bot[0] = 0,bot[1] = m-1?或者可能bot数组在初始化时不需要特别设置,因为它们的位置是固定的?可能需要根据题目中的结构体定义来看。题目中的结构体里,bot数组应该用于记录底的位置,所以初始化时,0的底是0,1的是m-1。因此,bot[0]=0,bot[1]=m-1?或者可能初始化的时候,top和bot的初始值相同?比如,0为空时,top[0]=-1,而bot[0]可能设为-1?这可能有问题。或者,bot数组可能被用来记录底的起始位置,例如0的bot是0,1的是m-1,而top数组的初始值则是top[0]=-1,top[1]=m。此时,bot数组可能只是保存初始的底位置,而top数组在操作时变化。 接下来,初始化函数需要做的事情是:给V分配大小为m的空间,设置top[0] = -1,top[1] = m,bot[0] = 0,bot[1] = m-1?或者可能bot数组的设置是否必要?比如,bot数组可能不需要动态改变,因为底的位置是固定的。可能题目中的结构体定义中的bot数组是冗余的,但根据题目给出的结构体,必须包含这些参数。所以,在初始化的时候,bot[0]应该设为0,bot[1]设为m-1吗? 然后,判断空的函数。对于i来说,当i=0时,top[0]==-1为空;i=1时,top[1]==m为空。所以判断空的条件很简单。 判断满的情况是当两个顶相遇,即top[0]+1 >= top[1]。例如,当0的top是k,1的top是k+1,这时候如果再压入0,top会变成k+1,此时已经等于1的top,所以无法再压入,即满。 进操作,需要先判断是否满。对于i,如果i=0,则top[0]加1,然后将元素放入V[top[0]]。i=1时,top[1]减1,然后放入元素。但要注意,当满的时候不能进。 出操作,需要判断对应的是否为空。如果i=0非空,则取出V[top[0]],然后将top[0]减1。i=1则取出V[top[1]],然后将top[1]加1?或者1的顶指针是递减的,所以当出时,应该将top[1]递增?比如,1的初始top是m,当压入一个元素后,top[1]变为m-1。此时,顶元素是V[m-1]。出时,应该将top[1]从m-1增加到m,这样再次变为空。因此,出操作对于1来说,是取出当前top[1],然后top[1]++。而进的时候,top[1]--。 那具体的函数该如何编写呢? 现在,我需要把这些逻辑转化为代码。因为是C语言的结构体,函数可能需要传入DblStack的指针。 初始化函数: DblStack* InitDblStack(int m) { DblStack *s = (DblStack*)malloc(sizeof(DblStack)); s->V = (SElemType*)malloc(m * sizeof(SElemType)); s->top[0] = -1; s->top[1] = m; s->bot[0] = 0; // 或者是否需要设置bot?可能根据题目结构体中的定义,bot可能记录的是底的位置,但底是固定的,所以这里可能不需要动态改变。例如,0的bot始终是0,1的bot始终是m-1? s->bot[1] = m-1; s->m = m; return s; } 或者可能bot数组的设置是否必要?或者题目中的结构体中的bot数组可能被用来动态记录底的位置?例如,可能的底部可以移动?但题目中说底分别处于数组的两端,说明是固定的。所以可能初始化时,bot[0]和bot[1]的值是固定的,但可能函数中不需要用到,因为底不动。因此,可能初始化时,bot数组的设置可以忽略?或者结构体中的bot数组可能被误定义,但根据题目要求,必须按照结构体定义来使用。比如,可能bot数组保存的是底的索引,所以初始化时,bot[0]=0,bot[1]=m-1。但可能在后续的操作中,这些值不变,所以其实可以不用维护。但在函数中可能需要用到吗? 可能题目中的结构体中的bot数组是多余的,或者可能用户需要将bot数组正确初始化。不管怎样,根据结构体定义,初始化时需要设置bot数组的值。例如,0的底在0,1在m-1。所以,初始化时,bot[0] = 0,bot[1] = m-1。那在初始化函数中,应该设置这些值。 然后是判断空的函数: bool IsEmpty(DblStack *s, int i) { if (i == 0) { return s->top[0] == -1; } else if (i == 1) { return s->top[1] == s->m; // 因为数组的大小是m,所以初始时top[1] = m,此时空。当压入元素后,top[1]变成m-1,m-2等。 } else { // 错误处理 return true; } } 或者原题中的数组是V[m],所以索引是0到m-1。当1的top[1]等于m的时候,空。例如,当top[1]等于m时,说明1中没有元素。如果压入一个元素,top[1]减1变成m-1,此时顶是m-1。当1的top[1]等于m时,空。所以在判断空时,i=1的条件是top[1] == m。因此,IsEmpty函数中,i=1的判断应该是s->top[1] == s->m。 满的判断条件是两个顶指针相邻。例如,当0的top[0]+1 >= 1的top[1]。例如,当0的top是k,1的top是k+1,这时候如果0要进,top[0]将变为k+1,此时k+1等于1的top[1],说明空间已满。因此,满的条件是s->top[0] + 1 >= s->top[1]。 因此,判断满的函数: bool IsFull(DblStack *s) { return (s->top[0] + 1) >= s->top[1]; } 进操作: bool Push(DblStack *s, int i, SElemType x) { if (IsFull(s)) { return false; // 满,无法进 } if (i == 0) { s->top[0]++; s->V[s->top[0]] = x; } else if (i == 1) { s->top[1]--; s->V[s->top[1]] = x; } else { return false; // 编号错误 } return true; } 出操作: bool Pop(DblStack *s, int i, SElemType *x) { if (IsEmpty(s, i)) { return false; // 空,无法出 } if (i == 0) { *x = s->V[s->top[0]]; s->top[0]--; } else if (i == 1) { *x = s->V[s->top[1]]; s->top[1]++; } else { return false; } return true; } 这样,这些函数应该可以完成初始化、判断空、满、进和出的操作。需要注意1的操作,进时top[1]递减,出时递增。 另外,初始化函数中的m参数是否正确?结构体中有一个m成员,表示的最大容量。初始化时,数组V的大小是m,所以m是的最大元素个数。因此,在初始化时,传入的m应该是数组的大小,结构体的m成员被设置为这个值。例如,用户创建双时,数组空间是V[m],所以双的m就是m。 然后,关于bot数组的使用,可能在题目给出的结构体中,bot数组是否需要被正确设置?例如,在初始化时,bot[0]设为0,bot[1]设为m-1?或者题目中的结构体可能并没有实际用到bot数组?例如,可能该结构体中的bot数组是冗余的,因为底的位置是固定的。但在函数中是否需要用到bot数组?例如,判断是否满的时候,可能不需要bot数组,而是直接比较两个的top指针。 综上所述,这些函数的实现应该正确。需要测试一些边界条件,例如当两个都填满整个数组的情况,或者其中一个为空的情况。 例如,当0压入m个元素的话,是不可能的,因为1的存在。例如,数组大小是m,0的top最多能增长到top[1]-1。例如,假设m=5,0的top初始是-1,1的top是5。当0压入元素,top[0]变为0,1,2,3,4。当1的top变为4时,此时满。所以,0最多压入到top[0]=3,1压入一个元素,此时0的top是3,1的top是4。此时再压入0的话,top[0]变成4,此时4 >=4,满,无法压入。 这样进和出的逻辑是正确的。</think>以下是对双结构的详细实现说明,包含初始化、判空、判满、进和出等操作的函数实现: --- ### **1. 双初始化** 初始化时需要完成以下操作: - 为双结构分配内存 - 初始化两个顶指针(0号`top[0] = -1`,1号`top[1] = m`) - 设置底指针(0号`bot[0] = 0`,1号`bot[1] = m-1`) - 为数组分配空间 ```c DblStack* InitDblStack(int m) { DblStack *s = (DblStack*)malloc(sizeof(DblStack)); s->V = (SElemType*)malloc(m * sizeof(SElemType)); s->top[0] = -1; // 0号初始为空 s->top[1] = m; // 1号初始为空 s->bot[0] = 0; // 0号底固定在数组起始位置 s->bot[1] = m - 1; // 1号底固定在数组末尾 s->m = m; // 最大容量 return s; } ``` --- ### **2. 判断空** 根据顶指针判断是否为空: - 0号空:`top[0] == -1` - 1号空:`top[1] == m` ```c bool IsEmpty(DblStack *s, int i) { if (i == 0) { return s->top[0] == -1; } else if (i == 1) { return s->top[1] == s->m; } return false; // 无效编号 } ``` --- ### **3. 判断满** 当两个顶相邻或交叉时,说明满: $$ \text{满条件:} \quad s->top[0] + 1 \geq s->top[1] $$ ```c bool IsFull(DblStack *s) { return (s->top[0] + 1) >= s->top[1]; } ``` --- ### **4. 进操作** 向指定压入元素: - 0号顶指针**递增**后写入数据 - 1号顶指针**递减**后写入数据 ```c bool Push(DblStack *s, int i, SElemType x) { if (IsFull(s)) return false; // 满无法插入 if (i == 0) { s->top[0]++; s->V[s->top[0]] = x; } else if (i == 1) { s->top[1]--; s->V[s->top[1]] = x; } else { return false; // 无效编号 } return true; } ``` --- ### **5. 出操作** 从指定弹出元素: - 0号:取出数据后顶指针**递减** - 1号:取出数据后顶指针**递增** ```c bool Pop(DblStack *s, int i, SElemType *x) { if (IsEmpty(s, i)) return false; // 空无法弹出 if (i == 0) { *x = s->V[s->top[0]]; s->top[0]--; } else if (i == 1) { *x = s->V[s->top[1]]; s->top[1]++; } else { return false; // 无效编号 } return true; } ``` --- ### **关键逻辑总结** | 操作 | 0号逻辑 | 1号逻辑 | |----------|--------------------------|--------------------------| | **进** | `top[0]++` 后写入数据 | `top[1]--` 后写入数据 | | **出** | 取出数据后 `top[0]--` | 取出数据后 `top[1]++` | | **空** | `top[0] == -1` | `top[1] == m` | | **满** | `top[0] + 1 >= top[1]` | `top[0] + 1 >= top[1]` | --- ### **示意图** ``` 数组索引: 0 1 2 ... m-2 m-1 0号方向 → → → → → → → → → 1号方向 ← ← ← ← ← ← ← ← ← 满条件:0号顶 +1 ≥ 1号顶 ``` --- 通过以上函数,可以实现双的共享存储空间管理,确保两个的高效操作。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值