循环链表&线性表（5.15）

练习:

创建一个n个节点环形链表(不包含头节点),然后输出这个环形链表

例如:

LinkNode *create_loop_linklist(int n)
{
当n为10的时候，这个环形链表中有:1,2,3,4,5,6,7,8,9,10 
返回第一个数据节点的地址
}

int printf_loop_linklist(LinkNode *p)
{

}

代码如下：

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

typedef int DATATYPE;

typedef struct node 
{
	DATATYPE data;
	struct node *next;
}LinkNode;

LinkNode *create_loop_linklist(int n)
{
	int i;
	LinkNode *p;
	LinkNode *temp;
	LinkNode *head;
	
	head = (LinkNode *)malloc(sizeof(LinkNode));
	head->data = 1;

	for(p = head,i = 2;i <= n;i ++)
	{
		temp = (LinkNode *)malloc(sizeof(LinkNode));
		temp->data = i;

		p->next = temp;

		p = p->next;//p = temp 让走到新节点的位置
	}

	p->next = head;
	
	return head;
}

int printf_loop_linklist(LinkNode *head)
{
	LinkNode *p;

	for(p = head;p->next != head;p = p->next)
	{
		printf("%d ",p->data);
	}
	printf("%d\n",p->data);

	return 0;
}

int main(int argc, const char *argv[])
{
	LinkNode *L = create_loop_linklist(10);
	
	printf_loop_linklist(L);

	return 0;
}

一 线性表 -------------------- 栈 

 

这里的栈本质是一种线性表，但是它规定数据先进后出，也就是说一种线性表只要它遵从"先进后出"的原则，就可以

认为它是栈。

 

一般的使用原则:先保存一些数据，到后面的时候才使用它，例如:界面的切换,表达式的计算...

 

1 + 3 * 5 + 6

 

思考:已知出栈的顺序是1,2,3,4，问进栈顺序可能是什么 

 

4,2,3,1

...

 

1.顺序栈

typedef struct 
{
	DATATYPE buf[MAX];//栈空间
	int top;//记录栈顶元素的位置
}SeqStack;

SeqStack *create_stack()
{
	SeqStack *s;

	s = malloc();
	s->top = 0;

	return s;
}

int is_empty_stack(SeqStack *s)
{
	return s->top == 0 ? 1 : 0;
}

int is_full_stack(SeqStack *s)
{
	return s->top == MAX ? 1 : 0;
}

int push_stack(SeqStack *s,DATATYPE data)
{
	...
}

//将出栈元素返回
DATATYPE pop_stack(SeqStack *s)
{
	...
}

DATATYPE get_top_data(SeqStack *s)
{
	....
}

int main()
{
	int i = 1;
	SeqStack *s = create_stack();

	while(!is_full_stack(s))
	{
		push_stack(s,i ++);
	}

	while(!is_empty_stack(s))
	{
		printf("%d ",pop_stack(s));
	}
	printf("\n");

	return 0;
}

代码如下：

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

typedef int DATATYPE;

#define MAX 10

typedef struct 
{
	DATATYPE buf[MAX];
	int top;
}SeqStack;


SeqStack *create_empty_stack()
{
	SeqStack *s;

	s = (SeqStack *)malloc(sizeof(SeqStack));
	s->top = 0;

	return s;
}

int is_empty_stack(SeqStack *s)
{
	return s->top == 0 ? 1 : 0;
}

int is_full_stack(SeqStack *s)
{
	return s->top == MAX ? 1 : 0;
}

int push_stack(SeqStack *s,DATATYPE data)
{
	if(is_full_stack(s))
	{
		printf("The stack is full!\n");
		return -1;
	}

	s->buf[s->top ++] = data;

	return 0;
}

DATATYPE pop_stack(SeqStack *s)
{
	if(is_empty_stack(s))
	{
		printf("The stack is empty!\n");
		return -1;
	}

	return s->buf[--s->top];
}

DATATYPE get_top_stack(SeqStack *s)
{
	return s->buf[s->top - 1];
}

int main(int argc, const char *argv[])
{
	int i = 1;
	SeqStack * s = create_empty_stack();
	
	while(!is_full_stack(s))
	{
		push_stack(s,i ++);
	}

	printf("top data : %d\n",get_top_stack(s));

	while(!is_empty_stack(s))
	{
		printf("%d ",pop_stack(s));
	}
	printf("\n");

	return 0;
}

2.链式栈 = 栈头 + 无头的链表

 

(1)栈中数据节点类型

typedef struct node 
{
	DATATYPE data;
	struct node *next;
}LinkNode;

(2)栈头的类型

typedef struct 
{
	LinkNode *top;//记录栈顶元素节点的地址
	int n;//记录栈中元素的个数
}LinkStack;

(3)创建一个空栈 

LinkStack *create_empty_linkstack()
{
	LinkStack *s;

	s = (LinkStack *)malloc(sizeof(LinkStack));
	s->top = NULL;
	s->n   = 0;

	return s;
}

(4)进栈

int push_linkstack(LinkStack *s,DATATYPE data)
{
	...
}

(5)出栈 

DATATYPE pop_stack(LinkStack *s)
{
	...
}

(6)判断栈是否为空

int is_empty_linkstack(LinkStack *s)
{
	return s->top == NULL ? 1 : 0;
}

代码如下：

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

typedef int DATATYPE;

//栈中数据节点类型
typedef struct node 
{
	DATATYPE data;
	struct node *next;
}LinkNode;

//栈头类型
typedef struct 
{
	LinkNode *top;//记录栈顶元素节点的地址
	int n;//栈中数据的个数
}LinkStack;

LinkStack *create_empty_linkstack()
{
	LinkStack *s;

	s = (LinkStack *)malloc(sizeof(LinkStack));
	s->top = NULL;
	s->n   = 0;

	return s;
}

int is_empty_linkstack(LinkStack *s)
{
	return s->top == NULL ? 1 : 0;
}

int push_linkstack(LinkStack *s,DATATYPE data)
{
	LinkNode *temp;

	temp = (LinkNode *)malloc(sizeof(LinkNode));
	temp->data = data;

	//用新节点保存栈顶的地址
	temp->next = s->top;

	//用s->top记录新栈顶的地址
	s->top     = temp;
	
	//更新n的值
	s->n ++;

	return 0;
}

DATATYPE pop_linkstack(LinkStack *s)
{
	DATATYPE data;
	LinkNode *temp;

	//获得栈顶元素的地址
	temp = s->top;

	//让s->top保存栈顶元素的下一个节点地址
	s->top = temp->next;
	
	//获得栈顶的值
	data = temp->data;

	//释放栈栈顶的节点
	free(temp);

	//更新n 
	s->n --;

	return data;
}

DATATYPE get_top_linkstack(LinkStack *s)
{
	return s->top->data;
}

int main(int argc, const char *argv[])
{
	int i = 0;
	LinkStack *s = create_empty_linkstack();
	
	for(i = 1;i <= 10;i ++)
	{
		push_linkstack(s,i);
	}

	printf("Top data : %d\n",get_top_linkstack(s));

	while(!is_empty_linkstack(s))
	{
		printf("%d ",pop_linkstack(s));
	}
	printf("\n");

	return 0;
}