8.6 双向链表和栈的使用

一.双向链表
struct node //双向链表
{
   ElemType data; //数据域
   struct node *next; //指针域指向下一个
   struct node *prior; //指向前一个
};
1.初始化
int LinkInit(Node **l)
{
   *l = (Node *)malloc(sizeof(Node) * 1); //分配头结点 l 就是头指针
   (*l)->next = NULL; //头结点指针域为空
   (*l)->prior = NULL; //双向链表，头结点prior指针为空
   return SUCCESS;
}
2.插入
int LinkInsert(Node *l, int n, ElemType e) //n 插入的位置
{
   Node *p = l;
   int k = 1; //k 移动的次数
   if (NULL == l)
   {
       return FAILURE;
   }
   while (k < n && p != NULL)
   {
       p = p->next;
       k++;
   }
   if (k > n || p == NULL)
   {
       return FAILURE;
   }
   Node *q = (Node *)malloc(sizeof(Node) * 1);
   if (NULL == q)
   {
       return FAILURE;
   }
   q->data = e;
   q->prior = p;
   q->next = p->next;
   p->next = q;
   if (NULL != q->next) //如果q不是最后一个结点
   {
       q->next->prior = q;
   }
   return SUCCESS;
}
其他的和单向链表差不多，就是要注意储存前一个节点的位置

二.双向循环链表
struct node //双向循环链表
{
   ElemType data; //数据域
   struct node *next; //指针域指向下一个
   struct node *prior; //指向前一个
};
1.初始化
int LinkInit(Node **l)
{
   *l = (Node *)malloc(sizeof(Node) * 1); //分配头结点 l 就是头指针
   (*l)->next = (*l); //头结点指针域为空
   (*l)->prior = (*l); //双向链表，头结点prior指针为空 **
   return SUCCESS;
}

2.插入
int LinkInsert(Node *l, int n, ElemType e) //n 插入的位置
{
   Node *p = l;
   int k = 1; //k 移动的次数
   if (NULL == l) //入参判断
   {
       return FAILURE;
   }
   if (n > LinkLength(l) + 1) //**
   {
       return FAILURE;
   }
   while (k < n) //***
   {
       p = p->next;
       k++;
   }
   if (k > n) //**
   {
       return FAILURE;
   }
   Node *q = (Node *)malloc(sizeof(Node) * 1);
   if (NULL == q)
   {
       return FAILURE;
   }
   q->data = e;
   q->prior = p;
   q->next = p->next;
   p->next = q;
   if (l != q->next) //如果q不是最后一个结点 **
   {
       q->next->prior = q;
   }
   return SUCCESS;
}

栈的定义
struct stack
{
   int top; //栈顶元素的位置（栈顶指针）
   ElemType *data;
};
栈的初始化
int StackInit(Stack **s)
{
   (*s) = (Stack *)malloc(sizeof(Stack) * 1); //分配一个结构体，用于保存栈的信息
   if(NULL == (*s))
   {
       return FAILURE;
   }

   (*s)->top = -1; //空栈，栈顶为-1
   (*s)->data = (ElemType *)malloc(sizeof(ElemType) * SIZE); //为栈分配空间
   if (NULL == (*s)->data)
   {
       return FAILURE;
   }

return SUCCESS;
}

进栈
int push(Stack *s, ElemType e)
{
   if (NULL == s || s->top == 9) //入参判断
   {
       return FAILURE;
   }

s->data[s->top + 1] = e; //进栈
s->top++;

return SUCCESS;
}

获取栈顶元素
int GetTop(Stack *s)
{
   if (s->top == -1)
   {
       return FAILURE;
   }
   return s->data[s->top];
}

出栈
int pop(Stack *s)
{
   if (s->top == -1)
   {
       return FAILURE;
   }
   s->top--;

return SUCCESS;
}

通过栈的概念对数进行排序：

#include <stdio.h>
#include "SequenceStack.h"

int main()
{
	int i, num, tmp;
	Stack *s1, *s2;

	if (StackInit(&s1) != SUCCESS || StackInit(&s2) != SUCCESS)
	{
		printf("Init Failure!\n");
	}

	for (i = 0; i < SIZE; i++)
	{
		scanf("%d", &num);
		if (i == 0)
		{
			push(s1, num);
		}
		else
		{
			if (num >= GetTop(s1))
			{
				push(s1, num);
			}
			else
			{
				while (StackEmpty(s1) != TRUE && num < GetTop(s1))
				{
					tmp = GetTop(s1);	
					pop(s1);
					push(s2, tmp);
				}
				push(s1, num);
				while (StackEmpty(s2) != TRUE)
				{
					tmp = GetTop(s2);
					pop(s2);
					push(s1, tmp);
				}
			}
		}
	}

	for (i = 0; i < SIZE; i++)
	{
		printf("%d ", GetTop(s1));
		pop(s1);
	}
	return 0;
}

8.6 双向链表 和 栈的使用

猜你喜欢

8.6 双向链表和栈的使用