数据结构：栈与队列的python以及C结构体实现（顺序结构及链式结构)

一 .栈的实现图解

1.利用顺序表模拟栈

class LinelyStack :
    def __init__(self,size = 10,count = 0):
        self.tops = -1
        self.res = -1
        self.size = size
        self.count = count
        self.stack = [None] * self.size
    def __is__empty(self,):
        return self.tops == self.res
    def __is__fill(self,):
        return self.count == self.size
    def push(self,elem):  #入栈
        if not self.__is__fill() :
            self.tops += 1
            self.stack[self.tops] = elem
            self.count += 1
            return
        raise Exception('Stack has fill!')
    def pop(self,): #出栈
        if not self.__is__empty() :
            popNode = self.stack[self.tops]
            self.top -= 1
            self.count -= 1
            return popNode
        raise Exception('Stack has empty!')s
    def top(self):#返回栈顶元素
         if not self.__is__empty():
             return self.stack[self.tops]
         raise Exception('Stack has empty!')

2. 利用单向链表模拟栈

class LinklyStack(object) :
    #------------------------创建新结点------------------------
    __slots__ = 'elem','next','head','count'   #节约内存
    class Node :
        def __init__(self,elem,next):
            self.elem = elem
            self.next = next
    #-----------------------栈对象-----------------------------
    def __init__(self):
        self.head = None
        self.count = 0
    def __len__(self):
        return self.count
    def is_empty(self):
        return self.count == 0
    def push(self,elem):
        self.head = self.Node(elem,self.head)
        self.count += 1
    def top(self):
        if self.is_empty() :
            raise Exception('stack is empty!')
        return self.head.elem
    def pop(self):
        if self.is_empty() :
            raise Exception('stack is empty!')
        result = self.head.elem
        self.head = self.head.next
        self.count -= 1
        return result

2.2 C语言利用结构体实现栈

//单向链表模拟栈
# include <stdio.h>
# include <stdlib.h>
struct Node   //定义链表中的结点
{
	int Nums;    //数据域
	struct Node *Next;  //指针域
};

struct list
{
	struct Node *sNode;   //标识栈的栈顶
	struct Node *eNode;  //标识栈的栈底
	int count;
};

void push(struct list *list,int Nums)  //入栈
{ 
	/*创建新的结点并给结点赋值*/
	struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
	newNode->Nums = Nums;
	/*栈为空时的操作*/
	if(list->count == 0)
	{
		list->sNode = newNode;
		list->eNode = newNode;
		list->count ++;
	}
	/*栈非空*/
	else
	{
		newNode->Next = list->sNode;
		list->sNode = newNode;
		list->count ++;
	}	
}
int pop(struct list *list)  //抛出栈顶元素
{	
	if (list->count > 0)
	{
		struct Node *pNode = list->sNode;
		list->sNode = list->sNode->Next;
		return pNode->Nums;
	}
	printf("抱歉，栈为空栈"); 
}
int top(struct list *list) //返回栈顶元素但不删除
{
	if(list->count > 0)
	{
		struct Node *pNode = list->sNode;
		return pNode->Nums;
	}
	printf("抱歉，栈为空栈"); 
}
int size(struct list *list)
{
	return list->count;
}

int main()
{
	struct list list ={NULL,NULL,0};
	/*push(&list,elem)*/
	/*top(&list,elem)*/
	/*pop(&list,elem)*/
}

二.队列实现图解

3.利用顺序表模拟队列

class linelyQuene(object) :
    def __init__(self,count = 0,size = 10):
        self.tops = -1
        self.res = -1
        self.size = size
        self.count = count
        self.quene = [None] * self.size
    def __is_empty__(self):
        return self.tops == self.res
    def __is_fill__(self):
        return self.count == self.size
    def enquene(self,elem):  #入队列
        if not self.__is_fill__() :
            self.tops+= 1
            self.quene[self.tops] = elem
            self.count += 1
    def dequene(self): #出队列
        if not self.__is_empty__() :
            self.res += 1
            popNode = self.quene[self.res]
            self.count -= 1
            return popNode
    def top(self):
        return self.quene[self.tops]

4.利用单向链表模拟队列

class LinklyQuene(object) :
    #------------------创建新结点---------------
    __slots__ = 'elem','next','head','tail','count'
    class Node :
        def __init__(self,elem,next):
            self.elem = elem
            self.next = next
    #-----------------队列对象------------------
    def __init__(self):
        self.head = None
        self.count = 0
    def __len__(self):
        return self.count
    def is_empty(self):
        return self.count == 0
    def dequene(self):
        if self.is_empty() :
            raise Exception('Quene is empty!')
        pNode = self.head
        self.head = self.head.next
        self.count -= 1
        """
        删除结点之后，队列的长度减去1
        如果此时队列空了，那么尾指针就置空
        """
        if self.is_empty() :
            self.tail = None
        return pNode.elem
    def __edit__(self,elem):
        newNode = self.Node(elem,None)
        self.head = newNode
        self.tail = newNode
        self.count += 1

    def enquene(self,elem):
        if self.is_empty() :
            return self.__edit__(elem)
        newNode  = self.Node(elem,None)
        self.tail.next = newNode
        self.tail = newNode
        self.count += 1

    def top(self):
        if self.is_empty() :
            raise Exception('Quene is empty!')
        return self.head.elem

2.2 C语言通过结构体实现队列

#include <stdio.h>
#include <stdlib.h>

struct Node{
	int Nums ;
	struct Node *Next;
}; 
struct list{
	struct Node *sNode;  /*标识队列的头结点*/
	struct Node *eNode; /*标识队列的尾结点*/
	int count;
};

void enquene(struct list *list,int Nums)  /*入队*/
{
	/*创建新的结点*/
	struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
	newNode->Nums = Nums;

	if(list->count == 0) /*队列为空时插入结点*/
	{
		list->sNode = newNode;
		list->eNode = newNode;
		list->count ++;
	}
	else   /*队列非空时插入结点*/
	{	
		newNode->Next = NULL;
		list->eNode->Next = newNode; 
		list->eNode = newNode;
		list->count ++; 
	} 
}

int dequene(struct list *list) /出队
{	
	struct Node *pNode = list->sNode; 
	if(list->count > 0)
	{
		list->sNode = list->sNode->Next;
		pNode->Next = NULL;
		return pNode->Nums;
	}
	printf("抱歉，队列为空");
}

int top(struct list *list)  //返回队头元素
{
	struct Node *pNode = list->sNode; 
	if(list->count > 0)
	{
		return pNode->Nums;
	}
	printf("抱歉，队列为空");
	
}

int size(struct list *list)
{
	return list->count;
}


int main()
{
	struct list list ={NULL,NULL,0};
	/*
	enquene(&list,elems)
	dequene(&list,elems)
	top(&list,elems)
	size(&list,elems)
	*/
}