go语言数据结构

1队列结构

package main

import "fmt"

//定义队列结构
type Queue struct {
    elements []int
}

//工厂方法生成新队列
func NewQueue(len int) *Queue {
    return &Queue{make([]int, len)}
}

//入队
func (q *Queue) Push(e int) () {
    q.elements = append(q.elements, e)
}

//出队
func (q *Queue) Pop() int{
    popElement := q.elements[0]
    q.elements = q.elements[1 : len(q.elements)-1]
    return  popElement
}

//求长
func (q *Queue) Len() int {
    return len(q.elements)
}

func main() {
    q := NewQueue(10)
    q.elements = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
    fmt.Println(q.elements)
    fmt.Println(q.Len())
    fmt.Println(q.Pop())
    fmt.Println(q.Len())
}

package main

//定义节点
type StackNode struct{
    data interface{};
    next *StackNode;
}

//定义栈顶
type stack struct {
    top *StackNode;
}

//创建栈
func createStack() *stack{
    return &stack{};
}

/**
 * 入栈
 */
func (stack *stack)Push(data interface{}){
    //申请节点
    node := StackNode{};
    node.data = data;

    //如果top为空
    if stack.top == nil {
        stack.top = &node;
        return;
    }

    //如果top不为空，交换top与新插入节点的位置
    tmp := stack.top;
    stack.top = &node;
    stack.top.next = tmp;
}

/**
 *出栈
 */
func (stack *stack)Pop()  interface{}{
    //判断是否为空
    if (stack.Empty()) {
        return nil;
    }
    tmp := stack.top;
    stack.top = stack.top.next;
    return tmp;
}

/**
 * 判断栈是否为空
 */
func (stack *stack)Empty() bool{
    if stack.top == nil {
        return true;
    }
    return false;
}

/**
 * 返回栈顶指针
 */
func (stack *stack)Top() *StackNode{
    if stack.Empty()==true {
        return nil;
    }
    return stack.top;
}

package main

import "fmt"

type node struct {
    data interface{};
    next *node;
}

type quene struct {
    front *node;
    rear *node;
}

/**
 * 创建空队列
 */
func createQuene()  *quene{
    quene := quene{};
    node := node{};
    quene.rear = &node;
    quene.front =  &node;
    quene.front.next = nil;
    return &quene;
}

/**
 * 判断节点是否为空
 */
func (quene quene)emptyQuene()bool{
    if quene.front==quene.rear{
        return true;
    }
    return false;
}

/**
 * 队尾入队 队列队首->队尾
 */
func (quene *quene)push(data interface{}){
    node := node{};
    node.data = data;
    node.next = nil;
    if quene.front.next == nil {
        quene.front.next= &node
    }

    //交换尾部
    quene.rear.next = &node;
    quene.rear = &node;
}

/**
 * 出队
 */
func pop(quene *quene) *node{
    isEmpty := quene.emptyQuene();
    if isEmpty==false {
        node := quene.front
        quene.front = quene.front.next;
        return node;
    }
    return nil
}


func main()  {
    stack := createQuene();
    fmt.Println(stack);
    stack.push(1);

    fmt.Println(stack.front.next.data)
    fmt.Println(stack.rear.data)
    //fmt.Println(stack.front.next.next.data)

    stack.push(2);
    fmt.Println(stack.front.next.data)
    fmt.Println(stack.front.next.next.data)
    fmt.Println(stack.rear.data)

    stack.push(3);
    fmt.Println(stack.front.next.data)
    fmt.Println(stack.front.next.next.data)
    fmt.Println(stack.front.next.next.next.data)
    fmt.Println(stack.rear.data)

}