剑指offer-从尾到头打印链表

从尾到头打印链表

                                 

                               

/*   从尾到头打印链表 */
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

typedef struct ListNode
{
	int m_nKey;
	ListNode* m_pNext; 
}NODE,*PNODE;

PNODE create_list();
void traverse_list(PNODE);

int main()
{
	PNODE pTail=(PNODE)malloc(sizeof(NODE));
	pTail=create_list();
    traverse_list(pTail);
   
	return 0;
} 

PNODE create_list()
{
	int i,len=0,val;
	printf("请输入要生成的链表的结点个数：");
	scanf("%d",&len);
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败!\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pHead->m_pNext=NULL;
	for(i=0;i<len;i++)
	{
		printf("请输入第%d个结点的值：",i+1);
		scanf("%d",&val);
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		 if(NULL==pNew)
	   {
		printf("分配失败!\n");
		exit(-1);
	   } 
		pNew->m_nKey=val;
		pNew->m_pNext=pTail;
		pTail=pNew;
	}
	
	return pTail; 
}

void traverse_list(PNODE pTail)
{
	while(NULL!=pTail->m_pNext)
	{
		printf("%d ",pTail->m_nKey);
		pTail=pTail->m_pNext;
	}
	printf("\n");
	return;
}

                                               

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

typedef struct Node
{
	int data;
	struct Node* pNext;
}NODE,*PNODE;

typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom; 
}STACK,*PSTACK;

void initStack(PSTACK);//初始化栈 
void pushStack(PSTACK,int);//压栈 
void traverse(PSTACK);//遍历栈 
bool pop(PSTACK,int *);//出栈 
bool is_empty(PSTACK pS);
PNODE create_list();
void traverse_list(PNODE pHead);
void PrintListReversingly_Iteratively(PNODE,PSTACK);

int main()
{
	STACK S;
	int val;
    initStack(&S);
    PNODE pHead=create_list();
    traverse_list(pHead);
    PrintListReversingly_Iteratively(pHead,&S);
	return 0;
} 
void initStack(PSTACK pS)
{
	pS->pTop=(PNODE)malloc(sizeof(NODE));
	if(NULL==pS->pTop)
	{
		printf("动态内存分配失败!\n");
		exit(-1);
	}else
	{
		pS->pBottom=pS->pTop;
		pS->pTop->pNext=NULL;
	}
}

void pushStack(PSTACK pS,int val)
{
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		printf("动态内存分配失败!\n");
		exit(-1);
	}else
	{
		pNew->data=val;
	    pNew->pNext=pS->pTop;
	    pS->pTop=pNew; 
	}
	return;
}

void traverse(PSTACK pS)
{
  PNODE p=pS->pTop;
  while(pS->pBottom!=p)
   {
  	 printf("%d ",p->data);
  	 p=p->pNext;
   }
   printf("\n");
	return;	
}  

bool is_empty(PSTACK pS)
{
	if(pS->pBottom==pS->pTop)
	{
		return true;
	}else
	{
		return false;
	}
}

bool pop(PSTACK pS,int *pVal)
{
	if(is_empty(pS))
	{
	   return false;	
	}else
	{
	  PNODE p=pS->pTop;
	  *pVal=p->data;
	  pS->pTop=p->pNext;
	  free(p);
	  p=NULL;	
	  return true;	
	}
}

PNODE create_list()
{
	int i,len=0,val;
	printf("请输入要生成的链表的结点个数：");
	scanf("%d",&len);
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败!\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;
	for(i=0;i<len;i++)
	{
		printf("请输入第%d个结点的值：",i+1);
		scanf("%d",&val);
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		 if(NULL==pNew)
	   {
		printf("分配失败!\n");
		exit(-1);
	   } 
		pNew->data=val;
		pTail->pNext=pNew;
		pNew->pNext=NULL;
		pTail=pNew;
	}
	pHead=pHead->pNext;
	return pHead; 
}

void traverse_list(PNODE pHead)
{
	while(NULL!=pHead)
	{
		printf("%d ",pHead->data);
		pHead=pHead->pNext;
	}
	printf("\n");
	return;
}

void PrintListReversingly_Iteratively(PNODE pHead,PSTACK pS)
{
   	while(pHead!=NULL)
   	{
   	  	pushStack(pS,pHead->data);
   	  	pHead=pHead->pNext; 
	}
    traverse(pS);
}

                                          

/*
*   从尾到头打印链表 
*/
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

typedef struct ListNode
{
	int m_nKey;
	ListNode* m_pNext; 
}NODE,*PNODE;

PNODE create_list();
void traverse_list(PNODE pHead);
void PrintListReversingly_Recursively(PNODE pHead);

int main()
{
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	pHead=create_list();
    traverse_list(pHead);
    PrintListReversingly_Recursively(pHead);
	return 0;
} 

PNODE create_list()
{
	int i,len=0,val;
	printf("请输入要生成的链表的结点个数：");
	scanf("%d",&len);
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败!\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->m_pNext=NULL;
	for(i=0;i<len;i++)
	{
		printf("请输入第%d个结点的值：",i+1);
		scanf("%d",&val);
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		 if(NULL==pNew)
	   {
		printf("分配失败!\n");
		exit(-1);
	   } 
		pNew->m_nKey=val;
		pTail->m_pNext=pNew;
		pNew->m_pNext=NULL;
		pTail=pNew;
	}
	pHead=pHead->m_pNext;
	return pHead; 
}

void traverse_list(PNODE pHead)
{
	while(NULL!=pHead)
	{
		printf("%d ",pHead->m_nKey);
		pHead=pHead->m_pNext;
	}
	printf("\n");
	return;
}

void PrintListReversingly_Recursively(PNODE pHead)
{
	if(pHead!=NULL)
	{
		if(pHead->m_pNext!=NULL)
		{
			PrintListReversingly_Recursively(pHead->m_pNext);	        
		}
		printf("%d ",pHead->m_nKey);
		
	}
}