數據結構：棧與隊列的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)
	*/
}