两个栈实现一个链表,以及两个链表实现一个栈

使用两个栈实现一个链表

首先我们知道,栈是一个先进后出的结构,{1,2,3,4,5}这种数组按序入栈,则他们的出栈顺序就是{5,4,3,2,1},这是我们只需要把这个出栈得出的数组按照顺序在压入到另一个栈中就可以得到5,4,3,2,1(从栈顶到栈底)这样的栈内顺序,再对这个栈进行出栈操作就可以得到{1.2.3.4.5}这种先进先出的顺序,这种两个栈实现队列的方式,一般用于生成后缀表达式.
代码如下

package main

import "fmt"

type St struct {
	Top int

	Bot  int
	Max  int
	Body []int
}

func (st *St) push(val int) (bl bool) {
	if st.Top == st.Max+1 {
		bl = false;
		return
	}
	st.Body[st.Top] = val
	if st.Top != st.Max {
		st.Top++
	}
	bl = true;
	return
}

func (st *St) pull() (re int, bl bool) {
	if st.Top == st.Bot {
		bl = false
		return
	}
	re = st.Body[st.Top];
	st.Top--;
	bl = true
	return
}

func pullPro(st *St, st1 *St) (re int) {
	jp := true
	var reo int
	for jp {
		reo, jp = st.pull()
		if jp {
			st1.push(reo)
		}
	}

	jp = true
	for jp {
		reo, jp = st1.pull();
		if jp {
			fmt.Println(reo)
		}
	}
	return
}

func main() {
	t := []int{0, 1, 2, 3, 5, 6}
	st := St{
		Top:  5,
		Body: t,
		Bot:  0,
		Max:  5,
	}
	st1 := St{
		Top:  1,
		Body: t,
		Bot:  0,
		Max:  5,
	}

	a := []int{0, 7, 8, 9, 10, 11}
	st.Body = a;
	pullPro(&st, &st1)
}

需要注意的是,st栈为初始的数据栈,而st1则用于吧st修改成先进先出的格式,也就是说当st1不为空的时候,是不能把数据压入到st1中的,否则无法得到先进先出的顺序.

---

用两个队列实现一个栈

已知队列是先进先出的顺序,{1,2,3,4,5}这种输入顺序对应的输出顺序也是{1,2,3,4,5},如果要用两个队列实现一个栈,我们必须先把队列尾之前的节点全部压入另外一个队列中,然后再单独弹出队列的尾部.然后将第二个队列的节点再依次压入到第一个队列中,重复此操作,直到第一个队列中不存在节点.

package main

import "fmt"

type D struct {
	Font int
	Real int
	Body []int
	Max  int
	Size int
}

func (d *D) pull() (re int, error bool) {

	if d.Font == d.Real {
		re = 0
		error = false
		return
	}

	re = d.Body[d.Font];
	d.Font = (d.Font + 1) % d.Max;
	d.Size--
	error = true
	return
}

func (d *D) push(val int) (error bool) {
	f := (d.Real + 1) % d.Max
	if f == d.Font {
		error = false
		return
	}
	index := d.Real % d.Max
	d.Body[index] = val
	d.Real = f
	d.Size++
	error = true
	return
}

func AllPush(d1 *D, d2 *D) {
	judge := true
	var re int
	for d1.Size > 0 {
		for judge {

			if d1.Size > 1 {
				re, judge = d1.pull();
				if !judge {
					break
				}
				judge = d2.push(re)
			} else {
				break
			}
		}

		re, _ = d1.pull()
		fmt.Println(re)
		judge = true
		for judge {
			if d2.Size > 0 {

				re, judge = d2.pull()

				if !judge {
					break
				}
				judge = d1.push(re)
			} else {
				break
			}
		}
	}
}

func main() {
	d1 := D{
		Font: 0,
		Max:  5,
		Real: 5,
		Size: 5,
		Body: []int{1, 2, 3, 4, 5},
	}

	d2 := D{
		Font: 0,
		Max:  5,
		Real: 0,
		Size: 0,
		Body: []int{0, 0, 0, 0, 0},
	}

	AllPush(&d1, &d2)
}