标签:地址 tail stat star stream lang define turn fine
//==================================================================
// 《剑指Offer——名企面试官精讲典型编程题》代码
// 作者:何海涛
//==================================================================
// 面试题6:从尾到头打印链表
// 题目:输入一个链表的头结点,从尾到头反过来打印出每个结点的值。
#include<iostream>
#include<stack>
using namespace std;
struct ListNode
{
int m_nValue;
ListNode* m_pNext;
ListNode(){
}
};
// 创建一个结点
ListNode* CreateListNode(int value)
{
ListNode* pNode = new ListNode();
pNode->m_nValue = value;
pNode->m_pNext = nullptr;
return pNode;
}
// 链接两个结点(链表)
void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
if(pCurrent == nullptr)
{
printf("Error to connect two nodes.\n");
exit(1);
}
pCurrent->m_pNext = pNext;
}
// 打印某个结点的值
void PrintListNode(ListNode* pNode)
{
if(pNode == nullptr)
{
printf("The node is nullptr\n");
}
else
{
printf("The key in node is %d.\n", pNode->m_nValue);
}
}
// 打印pHead之后的链表
void PrintList(ListNode* pHead)
{
printf("PrintList starts.\n");
ListNode* pNode = pHead;
while(pNode != nullptr)
{
printf("%d\t", pNode->m_nValue);
pNode = pNode->m_pNext;
}
printf("\nPrintList ends.\n");
}
// 销毁从pHead开始之后的链表
void DestroyList(ListNode* pHead)
{
ListNode* pNode = pHead;
while(pNode != nullptr)
{
pHead = pHead->m_pNext;
delete pNode;
pNode = pHead;
}
}
// 往链表的末尾添加一个结点
void AddToTail(ListNode** pHead, int value)
{
ListNode* pNew = new ListNode();
pNew->m_nValue = value;
pNew->m_pNext = nullptr;
if(*pHead == nullptr)
{
*pHead = pNew;
}
else
{
ListNode* pNode = *pHead;
while(pNode->m_pNext != nullptr)
pNode = pNode->m_pNext;
pNode->m_pNext = pNew;
}
}
// 找到第一个含有某值的结点并删除该结点
void RemoveNode(ListNode** pHead, int value)
{
if(pHead == nullptr || *pHead == nullptr)
return;
ListNode* pToBeDeleted = nullptr;
// 第一个结点
if((*pHead)->m_nValue == value)
{
pToBeDeleted = *pHead;
*pHead = (*pHead)->m_pNext;
}
else
{
ListNode* pNode = *pHead;
while(pNode->m_pNext != nullptr && pNode->m_pNext->m_nValue != value)
pNode = pNode->m_pNext;
if(pNode->m_pNext != nullptr && pNode->m_pNext->m_nValue == value)
{
pToBeDeleted = pNode->m_pNext;
pNode->m_pNext = pNode->m_pNext->m_pNext;
}
}
if(pToBeDeleted != nullptr)
{
delete pToBeDeleted;
pToBeDeleted = nullptr;
}
}
void PrintListReversingly_Iteratively(ListNode* pHead)
{
std::stack<ListNode*> nodes;
ListNode* pNode = pHead;
while(pNode != nullptr)
{
nodes.push(pNode);
pNode = pNode->m_pNext;
}
while(!nodes.empty())
{
pNode = nodes.top();
printf("%d\t", pNode->m_nValue);
nodes.pop();
}
}
void PrintListReversingly_Recursively(ListNode* pHead)
{
if(pHead != nullptr)
{
if (pHead->m_pNext != nullptr)
{
PrintListReversingly_Recursively(pHead->m_pNext);
}
printf("%d\t", pHead->m_nValue);
}
}
// ====================测试代码====================
void Test(ListNode* pHead)
{
PrintList(pHead);
PrintListReversingly_Iteratively(pHead);
printf("\n");
PrintListReversingly_Recursively(pHead);
}
// 1->2->3->4->5
void Test1()
{
printf("\nTest1 begins.\n");
// pNode1作为第一个结点,注意没有头结点
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(2);
ListNode* pNode3 = CreateListNode(3);
ListNode* pNode4 = CreateListNode(4);
ListNode* pNode5 = CreateListNode(5);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
ConnectListNodes(pNode3, pNode4);
ConnectListNodes(pNode4, pNode5);
AddToTail(&pNode1, 10);
Test(pNode1);
DestroyList(pNode1);
}
// 只有一个结点的链表: 1
void Test2()
{
printf("\nTest2 begins.\n");
ListNode* pNode1 = CreateListNode(1);
Test(pNode1);
DestroyList(pNode1);
}
// 空链表
void Test3()
{
printf("\nTest3 begins.\n");
Test(nullptr);
}
int main(int argc, char* argv[])
{
Test1();
Test2();
Test3();
return 0;
}
#include<iostream>
#include<stack>
#include "time.h"
using namespace std;
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
// 结点值类型
typedef int ElemType;
Status visit(ElemType c){
printf("%d ", c);
return OK;
}
struct Node{
ElemType data;
Node* next;
};
// 定义链表
typedef struct Node* LinkList;
/* 初始化顺序链表 */
// 注意传递进来的是指针,因为需修改实参的值
// 注意LinkList* L是一个指向指针的指针,因为LinkList本来就是一个指针
Status InitList(LinkList* L){
// 产生头结点
*L = (LinkList)malloc(sizeof(Node));
if(*L == NULL){
return ERROR;
}
// 指针域暂时为空,因为还没有结点,数据域则不用管
(*L)->next = NULL;
return OK;
}
Status ListEmpty(LinkList L){
if(L->next != NULL){
return FALSE;
}
return TRUE;
}
int ListLength(LinkList L){
// 头结点肯定是有的,不用判断
int i = 0;
LinkList p = L->next;
while(p != NULL){
i++;
p = p->next;
}
return i;
}
/* 初始条件:链表L已存在,将L重置为空表 */
Status ClearList(LinkList* L){
LinkList q;
LinkList p = (*L)->next;
while(p != NULL){
// 中间结点q
q = p ->next;
free(p);
p = q;
}
// 头结点指针域重置为空(即表示空表)
(*L)->next = NULL;
return OK;
}
/* 初始条件:链表L已存在,用e返回L中第i个结点的数据值 */
Status GetElem(LinkList L, int i, ElemType *e){
// p指向链表第一个结点
LinkList p = L->next;
int j = 1;
while(p != NULL){
if(j == i){
*e = p->data;
return OK;
}
j++;
p = p->next;
}
return ERROR;
}
int GetLocation(LinkList L, ElemType e){
int i = 1;
LinkList p = L->next;
while(p != NULL){
if(p->data == e){
return i;
break;
}
i++;
p = p->next;
}
return ERROR;
}
/* 初始条件:L已存在,在L中的第i个位置插入一个值为e的结点 */
Status ListInsert(LinkList *L, int i, ElemType e){
// p应该指向头结点,因为此时链表可能为空
// 可以理解为j是p之后的一个结点
LinkList p = *L;
int j = 1;
// 插入的结点s
LinkList s;
// 注意和删除结点写法不一样,因为当只有头结点的时候,是空表,如果写为p->next!=NULL则永远都插不上
while(p != NULL && j<i){
p = p->next;
j++;
}
if(p == NULL || j>i){
return ERROR;
}
s = (LinkList)malloc(sizeof(Node));
s->data = e;
s->next = p->next;
p->next = s;
return OK;
}
Status ListDelete(LinkList* L, int i, ElemType *e){
// p应该指向头结点,因为此时链表可能为空
// 可以理解为j是p之后的一个结点
LinkList p = *L;
int j = 1;
// 删除的结点q
LinkList q;
while(p->next != NULL && j<i){
p = p->next;
j++;
}
if(p->next == NULL || j>i)
return ERROR;
q = p->next;
p->next = q->next;
*e = q->data;
free(q);
return OK;
}
Status ListTraverse(LinkList L){
LinkList p = L->next;
while(p != NULL){
visit(p->data);
p = p->next;
}
printf("\n");
return OK;
}
// 插队法建立一个链表
void CreateListHead(LinkList* L, int n){
LinkList p;
int i;
srand(time(0));
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL;
for(i = 1; i <= n; i++){
p = (LinkList)malloc(sizeof(Node));
p->data = rand()%100 + 1;
p->next = (*L)->next;
(*L)->next = p;
}
}
void CreateListTail(LinkList* L, int n){
LinkList p, r;
int i;
srand(time(0));
*L = (LinkList)malloc(sizeof(Node));
r = *L;
for(i = 1; i <= n; i++){
p = (LinkList)malloc(sizeof(Node));
p->data = rand()%100 +1;
r->next = p;
r = p;
}
r->next = NULL;
}
int main(){
LinkList L;
int num;
Status s;
// 传递地址给函数,创建一个带头结点的“空链表”
// 必须要初始化,分配一个头节点内存,不然程序错误
s = InitList(&L);
printf("%d\n", s);
// 插入元素
for(int i = 1; i<=5; i++){
ListInsert(&L, i, i);
}
ListInsert(&L, 10, 99);
num = ListLength(L);
printf("%d\n", num);
// 遍历元素
ListTraverse(L);
stack<LinkList> nodes;
LinkList p = L->next;
while(p != NULL){
nodes.push(p);
p = p->next;
}
while(!nodes.empty()){
p = nodes.top();
printf("%d ", p->data);
nodes.pop();
}
return 0;
}
??第一个剑指offer的版本是用C++写的,与之后的大话数据结构的不一样,后者是用C写的。两者在定义结构体的时候有一个小小的区别,但就引起了代码巨大的区别。
??C++版本的代码中,使用struct定义了一个结构体(类),没有使用typedf为结构体更名,但是C版本的代码中使用了typedef struct Node *LinkList;
这句代码,因此定义LinkList本来就是一个指针类型。从此之后,在C的各种链表操作函数中,将某一个结点声明为LinkList p
即可,但在C++版本中则需要声明为ListNode* p
,但两者意思是一样的。
??因此在剑指offer的57页中,有句“我们要特别注意函数的第一个参数pHead是一个指向指针的指针,即ListNode** pHead
”,这其实就是因为需要修改头指针的值。如此,在C版本中的函数中,声明为LinkList* L
也是一个指向指针的指针,一个意思。
??两者还有一个区别就是,剑指offer版本是没有头结点的,但是大话数据结构是有头结点的。
??若要头结点,则在程序开始的时候应该初始化一个只有头结点的链表。
??只要涉及到修改头结点/头指针,都需要将参数设置为指向指针的指针。
标签:地址 tail stat star stream lang define turn fine
原文地址:https://www.cnblogs.com/flyingrun/p/13279058.html