一个数组实现两个栈 c语言,一个数组实现两个栈

最新推荐文章于 2022-03-18 16:56:52 发布
最新推荐文章于 2022-03-18 16:56:52 发布
阅读量302 收藏
点赞数
文章标签： 一个数组实现两个栈 c语言

题目：

一个数组A[1..n]来实现两个栈，使得两个栈中的元素总和不到n时，两个都不会发生上溯。

思路(1)：

创建一个数组，分别从两边开始，依次往中间走。

1c873351fbf4d257288afb62105e96d7.png

思路(2)：

创建一个数组，一个走奇数位，一个走偶数位。

811195785dfb469626cfcd587a3fe3e6.png//奇偶方式

#define  _CRT_SECURE_NO_WARNINGS

#include

using namespace std;

template

class TwoStack

{

public:

TwoStack(int size)

:_top1(-1), _top2(-1), _len(size)

{

_arr = new T[size];

}

~TwoStack()

{

if (_arr)

{

delete[] _arr;

}

}

void Push(int index, int data);

T Pop(int index);

bool IsEmpty(int index);

void Disp();

T Top(int index);

private:

int _top1;

int _top2;

int _len;

T* _arr;

};

template

void TwoStack::Push(int index, int data)

{

//if (_len % 2 == 0)

//{

//if (_top1>_len-2 || _top2>=_len-1)

//{

//cout <

//return;

//}

//}

//else

//{

//if (_top1 >_len || _top2 >= _len - 2)

//{

//cout <

//return;

//}

//}

int flag = _len % 2;

if (index == 0)

{

if (flag == 0)

{

if (_top1 >= _len - 2)

{

cout <

return;

}

}

if (flag == 1)

{

if (_top1 >= _len - 1)

{

cout <

return;

}

}

if (_top1 == -1)

{

_top1 = 0;

_arr[_top1] = data;

}

else

{

_top1+=2;

_arr[_top1] = data;

}

}

/

else

{

if (flag == 0)

{

if (_top2 >= _len - 2)

{

cout <

return;

}

}

if (flag == 1)

{

if (_top2 >= _len - 1)

{

cout <

return;

}

}

///

if (_top2 == -1)

{

_top2 = 1;

_arr[_top2] = data;

}

else

{

_top2+=2;

_arr[_top2] = data;

}

}

}

template

T TwoStack::Pop(int index)

{

int ret;

if (index == 0)

{

if (_top1 

{

cout <

return -1;

}

else

{

ret = _arr[_top1];

_top1-=2;

}

}

else

{

if (_top2 <1)

{

cout <

return -1;

}

else

{

ret = _arr[_top2];

_top2-=2;

}

}

return ret;

}

template

bool TwoStack::IsEmpty(int index)

{

if (index == 0 && _top1 

return true;

if (index == 1 && _top2 

return true;

return false;

}

template

void TwoStack::Disp()

{

{

for (int i = 0; i 

{

cout <

}

}

}

template

T TwoStack::Top(int index)

{

if (0 == index && _top1 >= 0)

{

return _arr[_top1];

}

if (1 == index && _top2 >=1)

{

return _arr[_top2];

}

cout <

exit(0);

}

void test1()

{

TwoStacks(10);

s.Push(0, 1);

s.Push(0, 2);

s.Push(0, 3);

s.Push(0, 4);

s.Push(0, 5);

//s.Push(0, 5);

s.Push(1, 6);

s.Push(1, 7);

s.Push(1, 8);

s.Push(1, 9);

s.Push(1, 10);

//s.Push(1, 10);

//cout <

//cout<

s.Disp();

}

void test2()

{

TwoStacks(10);

s.Push(0, 1);

s.Push(0, 2);

s.Push(0, 3);

s.Push(0, 4);

s.Push(0, 5);

s.Push(1, 6);

s.Push(1, 7);

s.Push(1, 8);

s.Push(1, 9);

s.Push(1, 10);

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

//cout<

}

int main()

{

test1();

test2();

system("pause");

return  0;

}

一前一后向中间走：#define  _CRT_SECURE_NO_WARNINGS

#include

using namespace std;

template

class TwoStack

{

public:

TwoStack(int size)

:_top1(-1), _top2(size), _len(size)

{

_arr = new T[size];

}

~TwoStack()

{

if (_arr)

{

delete[] _arr;

}

}

void Push(int index, int data);

T Pop(int index);

bool IsEmpty(int index);

void Disp();

T Top(int index);

private:

int _top1;

int _top2;

int _len;

T* _arr;

};

template

void TwoStack::Push(int index, int data)

{

if (_top1 >= _top2 - 1)

{

cout <

return;

}

if (index == 0)

{

_top1++;

_arr[_top1] = data;

}

else

{

_top2--;

_arr[_top2] = data;

}

}

template

T TwoStack::Pop(int index)

{

int ret;

if (index == 0)

{

if (_top1 

{

cout<

return -1;

}

else

{

ret = _arr[_top1];

_top1--;

}

}

else

{

if (_top2 > _len)

{

cout <

return -1;

}

else

{

ret = _arr[_top2];

_top2++;

}

}

return ret;

}

template

bool TwoStack::IsEmpty(int index)

{

if (index == 0 && _top1 

return true;

if (index == 1 && _top2 >= _len)

return true;

return false;

}

template

void TwoStack::Disp()

{

{

for (int i = 0; i 

{

cout <

}

}

}

template

T TwoStack::Top(int index)

{

if (0 == index && _top1>=0)

{

return _arr[_top1];

}

if (1 == index && _top2 

{

return _arr[_top2];

}

cout <

exit(0);

}

void test1()

{

TwoStacks(10);

s.Push(0, 1);

s.Push(0, 2);

s.Push(0, 3);

s.Push(0, 4);

s.Push(0, 5);

//s.Push(0, 5);

s.Push(1, 6);

s.Push(1, 7);

s.Push(1, 8);

s.Push(1, 9);

s.Push(1, 10);

//s.Push(1, 10);

s.Disp();

//cout <

}

void test2()

{

TwoStacks(10);

s.Push(0, 1);

s.Push(0, 2);

s.Push(0, 3);

s.Push(0, 4);

s.Push(0, 5);

s.Push(1, 6);

s.Push(1, 7);

s.Push(1, 8);

s.Push(1, 9);

s.Push(1, 10);

//cout<

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

//cout<

}

int main()

{

test1();

//test2();

system("pause");

return  0;

}

动态实现增长：

#define  _CRT_SECURE_NO_WARNINGS

#include

using namespace std;

template

class TwoStack

{

public:

TwoStack()

:_top1(-1), _top2(-1), _len(0), _arr(NULL), _capacity(0)

{

}

~TwoStack()

{

if (_arr)

{

delete[] _arr;

}

}

void Push(int index, int data);

T Pop(int index);

bool IsEmpty(int index);

void Disp();

T Top(int index);

void IncreaseCapcity();

private:

int _top1;

int _top2;

int _len;

T* _arr;

int _capacity;

};

template

void TwoStack::IncreaseCapcity()

{

int top1 = _top1;

int top2 = _top2;

int size = _capacity;

_capacity = _len * 2 + 3;

int capacity = _len * 2 + 3;

int newlen = capacity;

T* tmp = new T[_capacity];

if (_arr != NULL)

{

for (int i = 0; i <= top1; i++)

{

tmp[i] = _arr[i];

}

for (int j = top1 + 1; j 

{

tmp[--capacity] = _arr[--_len];

--newlen;

}

}

if (_arr != NULL)

{

delete[] _arr;

}

_arr = tmp;

_len = newlen;

_top2 = _len;

}

template

void TwoStack::Push(int index, int data)

{

if (_top1 >= _top2 - 1)

{

IncreaseCapcity();

}

if (index == 0)

{

_top1++;

_arr[_top1] = data;

}

else

{

_top2--;

_arr[_top2] = data;

}

}

template

T TwoStack::Pop(int index)

{

int ret;

if (index == 0)

{

if (_top1 

{

cout<

return -1;

}

else

{

ret = _arr[_top1];

_top1--;

}

}

else

{

if (_top2 > _len)

{

cout <

return -1;

}

else

{

ret = _arr[_top2];

_top2++;

}

}

return ret;

}

template

bool TwoStack::IsEmpty(int index)

{

if (index == 0 && _top1 

return true;

if (index == 1 && _top2 >= _len)

return true;

return false;

}

template

void TwoStack::Disp()

{

{

for (int i = 0; i 

{

cout <

}

}

}

template

T TwoStack::Top(int index)

{

if (0 == index && _top1>=0)

{

return _arr[_top1];

}

if (1 == index && _top2 

{

return _arr[_top2];

}

cout <

exit(0);

}

void test1()

{

TwoStacks;

s.Push(0, 1);

s.Push(0, 2);

s.Push(0, 3);

s.Push(0, 4);

s.Push(0, 5);

//s.Push(0, 5);

//cout <

//cout <

//cout <

//cout <

//cout <

s.Push(1, 6);

s.Push(1, 7);

s.Push(1, 8);

s.Push(1, 9);

s.Push(1, 10);

//s.Push(1, 10);

s.Disp();

//cout <

}

void test2()

{

TwoStacks;

s.Push(0, 1);

s.Push(0, 2);

s.Push(0, 3);

s.Push(0, 4);

s.Push(0, 5);

s.Push(1, 6);

s.Push(1, 7);

s.Push(1, 8);

s.Push(1, 9);

s.Push(1, 10);

//cout<

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

cout <

//cout<

}

int main()

{

test1();

//test2();

system("pause");

return  0;

}

谢乾
关注
在一个数组中实现两个堆栈
何妨吟啸且徐行
11-10 1444
函数接口定义：     Stack CreateStack( int MaxSize ); bool Push( Stack S, ElementType X, int Tag ); ElementType Pop( Stack S, int Tag ); 其中Tag是堆栈编号，取1或2；MaxSize堆栈数组的规模；Stack结构定义如下：     typedef...
一个数组实现两个栈（共享栈）（扩容）
zhao_miao的博客
08-26 1500
  一个数组实现两个栈的具体方法：一个数组实现两个栈（共享栈）但是上述方法的缺陷是数组的大小是恒定的，当数组满的时候就无法进行入栈操作。这篇博客我们将讲一下数组如何扩容？   实现方法：一个数组实现两个栈=====&gt;&gt;下标为0的位置为栈1的栈底，栈2的栈底在下标最大的位置上。栈1向左扩展，栈2向后扩展。若数组已满则增容。   首先定义一个共享栈的结构体： #define ...
一个数组实现两个栈
ArchyLi
10-24 777
看到这个题目，大概会想到三种方法实现：（1）用奇数位下标存放一个栈的内容，用偶数位下标存放另外一个栈的内容。（2）从数组的中间一分为二，左边是一个栈，右边是一个栈，分别向两边延伸，栈底都是中间，栈顶向两边。（3）数组的两边分别做两个栈的栈底，两个栈向中间生长。简单的分析后，我们知道其他两种方法在运用的过程中总会产生更多的空间浪费，所以我们认为第三种方法是最好的，下面我们给出第三种方法的实现：代码如下
【C语言】用一个数组实现两个堆栈
weixin_51444573的博客
03-18 2927
双向栈就是利用一个数组的两端作为栈顶，同时向数组中间增长，实现一个数组由两个栈共享 结合书本上的内容我在此发表一些我的理解： 1.双堆栈的建立 首先由图中能看出建立一个双堆栈我们需要一个数组，两个栈顶指针Top1和Top2，同时我们还需要定义数组的最大长度MaxSize。在最初数组中没有存放元素，所以栈顶指针1和栈顶指针2都不会指向数组中的位置，所以初始化双堆栈时栈顶指针1指向的位置是数组最左边位置0的前一个位置即-1，而栈顶指针2就指向数组最右端的位置MaxSize-1的下一个位置即MaxSiz
（C语言）判断两个数组所含元素是否相同
02-05
判断两个数组所含元素是否相同，数量也要相同。
c语言基础-c语言编程基础之数组操作示例-两个数组的交集.zip
03-17
在C语言中，数组是一种...总的来说，C语言中的数组操作是学习编程的基础，而找出两个数组的交集是数组操作中的一个典型问题，它涉及到排序和双指针等技巧。通过掌握这些知识，你可以更好地理解和解决实际的编程问题。
c语言 利用字符数组实现两个大整数的加减法.exe
12-19
c语言 利用字符数组实现两个大整数的加减法.exe
一个数组实现两个栈 c语言,一个数组实现两个栈的例程
weixin_39752434的博客
05-22 422
//该程序仅用一个数组而实现两个栈的例程。//除非数组的每一个单元都被使用//否则你的栈例程不能有溢出声明#include #include #define MinStackSize (5)typedef struct Node *dbstack; //双栈dbstack CreatStack(int MaxElements); //构建一个大小为MAXElements的数组void...
C语言在一个数组中实现两个栈
wwxy1995的博客
09-10 782
在一个数组中实现两个栈，并实现入栈，出栈操作 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define ERROR 1e8 typedef int ElementType; typedef enum { push, pop, end } Operation; typedef enum { false, true } bool; ty...
~一个数组实现两个栈~
眼与泪的诀别的博客
04-16 620
~一个数组实现两个栈~
一个数组实现两个栈（共享栈）
热门推荐
zhao_miao的博客
08-23 1万+
题目：   一个数组实现两个栈。 方法1：   下标为0的位置为栈1的栈底，下标为1的位置为栈2的栈底，栈1的元素存放在下标为偶数的位置上，栈2的元素放在下标为奇数的位置上。   如上图所示的数组：若栈1有一个元素 2，栈2有6个元素 1，2，3，4，5，6，下标为0的位置为 2，下标为1，3，5，7，9的位置分别为1，2，3，4，5。6无法插入但数组中还有很多剩余的空间。。可见该方法会...
怎么将两个数组和为一个数组c语言
最新发布
09-09
在C语言中，将两个数组合并成一个数组通常涉及创建一个足够大的新数组来存储两个数组的元素，然后将这两个数组的内容依次复制到新数组中。下面是一个简单的示例代码，展示了如何将两个整型数组合并成一个数组： ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值