一些实例
1、定义一个结构体数组用以保存5个学生的以下信息：学号、姓名、性别、家庭住址、3门课程成绩。
要求：
1.从键盘输入5个学生的数据。
2.显示5个学生中有一门不及格和所有课程均不及格的人数。
3.检索学号为NUM的学生的3门课程成绩，NUM由键盘输入。
#include <stdio.h>
#define STUSIZE 5
struct student
{
int num;
char name[20];
char sex[4];
char homeaddr[50];
float yuwen;
float shuxue;
float waiyu;
};
//输入学生信息
void input_stu(struct student p[])
{
int i;
for (i=0; i<STUSIZE; i++)
{
printf("请输入第%d个学生信息：\n", i+1);
printf("请输入学号：\n");
scanf("%d", &p[i].num);
printf("请输入姓名：\n");
scanf("%s", &p[i].name);
printf("请输入性别：\n");
scanf("%s", &p[i].sex);
printf("请输入住址：\n");
scanf("%s", &p[i].homeaddr);
printf("请输入语文成绩：\n");
scanf("%f", &p[i].yuwen);
printf("请输入数学成绩：\n");
scanf("%f", &p[i].shuxue);
printf("请输入外语成绩：\n");
scanf("%f", &p[i].waiyu);
}
}
//检索学生信息
void findstu(struct student stu[], int num)
{
int i = 0;
for(i=0; i<STUSIZE; i++)
{
if(stu[i].num == num)
{
printf("此学生三门课成绩为：语文%.2f 数学%.2f 外语%.2f\n",stu[i].yuwen,stu[i].shuxue, stu[i].waiyu);
break;
}
else
{
printf("未找到此学生！\n");
}
}
}
//显示不及格学生人数
void showstu(struct student stu[])
{
int i, icount=0, acount=0;
for(i=0; i<STUSIZE; i++)
{
if(stu[i].yuwen < 60 || stu[i].shuxue < 60 || stu[i].waiyu < 60)
{
icount ++;
}
if(stu[i].yuwen < 60 && stu[i].shuxue < 60 && stu[i].waiyu < 60)
{
acount ++;
}
}
printf("有一门不及格的人数是：%d 所有课程都不及格的人数是： %d", icount, acount);
}
int main()
{
int n=0;
struct student stu[STUSIZE] = {0};
input_stu(stu);
printf("请输入要检索的学生学号：\n");
scanf("%d", &n);
findstu(stu, n);
showstu(stu);
return 0;
}
2、字符串翻转和每个单词翻转
#include <stdio.h>
#include <string.h>
#define MAX_STRING 200
void reverse_string(char str[MAX_STRING], int start, int end)
{
char tmp = 0;
//翻转字符串
while (start < end) //如果前标小于后标
{
//交换两个元素值
tmp = str[start];
str[start] = str[end];
str[end] = tmp;
//改变索引值
++start;
--end;
}
}
int main()
{
int i = 0, j = 0;
char str[MAX_STRING] = {0};
int length = 0;
char tmp = 0;
int start = 0, end = 0;
printf("输入一个字符串：\n");
gets(str);
length = strlen(str);
reverse_string(str, 0, length-1);
printf("第一步： \n");
printf("%s\n", str);
//依次翻转其中的每一个单词
while (i < length)
{
//翻转其中的一个单词
if (str[i] != ' ')
{
//找到单词的开头
start = i;
while (str[i] != ' ' && str[i] != '\0')
{
//找到单词的结尾
++i;
reverse_string(str, start, i-1);
}
++i;
}
}
printf("第二步： \n");
printf("%s\n", str);
return 0;
}
3、删除数组重复的元素
#include <stdio.h>
void output(int a[], int n)
{
int i;
for (i=0; i<n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int deleteElement(int a[], int n, int x)
{
int i, j, k, num=0;
int temp[6] = {0};
for (i=0; i<n; i++)
{
if (a[i] == x)
{
for (j=i; j<n; j++) //找到符合条件的元素下标，
{
a[j] = a[j+1]; //用后一个元素覆盖找到的元素
}
num++;
}
}
return n-num;
}
int main()
{
int a[6] = {9,5,6,7,8,5};
int num = 0;
output(a, 6);
num = deleteElement(a, 6, 5);
printf("数组现在还有%d项\n", num);
output(a, num);
getchar();
return 0;
}4、链表的建立、添加、查询、插入、删除、销毁
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
struct LinkNode
{
int data;
struct LinkNode *next;
};
struct LinkNode *head = NULL;
struct LinkNode * CreateLink(void);
void OutputLink(struct LinkNode *);
void EndInsertNode(struct LinkNode *);
void HeadInsertNode(struct LinkNode *);
struct LinkNode *FindNode(int n);
void InsertNode(struct LinkNode *);
void DeleteNode(struct LinkNode *);
void DestroyLink(struct LinkNode *);
int main(void)
{
struct LinkNode *phead, *pfind;
int n = 0;
phead = CreateLink();
OutputLink(phead);
printf("用尾插法添加数据：\n");
EndInsertNode(phead);
OutputLink(phead);
printf("用头插法添加数据：\n");
HeadInsertNode(phead);
OutputLink(phead);
printf("插入数据：\n");
InsertNode(phead);
OutputLink(phead);
printf("删除数据：\n");
DeleteNode(phead);
OutputLink(phead);
printf("销毁链表：\n");
DestroyLink(phead);
return 0;
}
struct LinkNode * CreateLink(void)
{
int i = 0, n = 0;
struct LinkNode *phead, *pend, *pmove;
phead = (struct LinkNode *)malloc(sizeof(struct LinkNode));
if (NULL == phead)
{
printf("内存分配失败，程序终止！\n");
exit(-1);
}
phead->next = NULL;
head = phead;
pend = phead;
printf("输入要建立的结点数：\n");
scanf("%d", &n);
getchar();
printf("输入结点数值：\n");
for (i = 0; i < n; i++ )
{
pmove = (struct LinkNode *)malloc(sizeof(struct LinkNode));
if (NULL == pmove)
{
printf("内存分配失败，程序终止！\n");
exit(-1);
}
scanf("%d", &pmove->data);
getchar();
pend->next = pmove;
pmove->next = NULL;
pend = pmove;
}
return phead;
}
void OutputLink(struct LinkNode *phead)
{
struct LinkNode *move = phead->next;
while (NULL != move)
{
printf("%3d", move->data);
move = move->next;
}
printf("\n");
}
void EndInsertNode(struct LinkNode *phead)
{
int number = 0;
struct LinkNode *pnow, *pmove;
pnow = phead;
if (NULL == phead)
{
printf("链表为空。\n");
exit(-1);
}
while (NULL != pnow->next)
{
pnow = pnow->next;
}
printf("输入要添加的数(输入-1结束)：\n");
while (1)
{
pmove = (struct LinkNode *)malloc(sizeof(struct LinkNode));
scanf("%d", &number);
if (number != -1)
{
pmove->data = number;
pnow->next = pmove;
pmove->next = NULL;
pnow = pmove;
}
else
break;
}
}
void HeadInsertNode(struct LinkNode *phead)
{
int number = 0;
struct LinkNode *pnow, *pmove;
if (NULL == phead)
{
printf("链表为空。\n");
exit(-1);
}
pnow = phead;
printf("输入要添加的数(输入-1结束)：\n");
while (1)
{
pmove = (struct LinkNode *)malloc(sizeof(struct LinkNode));
scanf("%d", &number);
if (number != -1)
{
pmove->data = number;
pmove->next = pnow->next;
pnow->next = pmove;
}
else
break;
}
}
struct LinkNode *FindNode(int n)
{
struct LinkNode *phead, *pnow, *pfind = NULL;
phead = head;
pnow = phead;
if (NULL == phead)
{
printf("链表为空。\n");
exit(-1);
}
while (NULL != pnow->next)
{
if (pnow->data == n)
{
pfind = pnow;
printf("%d\n", pnow->data);
return pfind;
}
pnow = pnow->next;
}
printf("未找到！");
}
void InsertNode(struct LinkNode *phead)
{
int num = 0;
struct LinkNode *move = phead, *pfind = NULL;
printf("输入要在哪个数值后插入新的数值：\n");
scanf("%d", &num);
getchar();
while (NULL != move)
{
if (move->data == num)
{
pfind = (struct LinkNode *)malloc(sizeof(struct LinkNode));
printf("输入要插入的数：\n");
scanf("%d", &pfind->data);
if (move->next == NULL)
{
move->next = pfind;
pfind->next = NULL;
}
else
{
pfind->next = move->next;
move->next = pfind;
}
return;
}
move = move->next;
}
printf("未找到！\n");
}
void DeleteNode(struct LinkNode *phead)
{
int num = 0;
struct LinkNode *pnow = phead, *pfind = NULL;
printf("输入要删除的数：\n");
scanf("%d", &num);
while (NULL != pnow->next)
{
if (pnow->next->data == num)
{
pfind = pnow->next;
if (pfind->next != NULL)
{
pnow->next = pnow->next->next;
}
else
{
pnow->next = NULL;
}
free(pfind);
pfind = NULL;
return;
}
pnow = pnow->next;
}
printf("无该结点！\n");
}
void DestroyLink(struct LinkNode *phead)
{
struct LinkNode *save = phead;
while (NULL != phead)
{
save = phead->next;
free(phead);
phead = save;
}
if (NULL == phead)
{
printf("链表已销毁！\n");
}
}5、数据结构-线性表-顺序表
#include <stdio.h>
#include <stdlib.h>
#define MAXLISTSIZE 1024 //定义顺序表最大容量
//定义顺序表节点类型
typedef struct
{
int data[MAXLISTSIZE]; //顺序表
int last; //顺序表元素个数
}linearlist;
void ListList(linearlist *list) //打印线性顺序表
{
int i;
printf("当前线性表的状态：\n");
if (list->last == 0)
{
printf("当前顺序表为空");
}
else
{
for (i=0; i<list->last; i++)
{
printf("[%4d]", list->data[i]);
}
}
printf("\n");
}
void Output(linearlist *list) //打印说明文档
{
system("cls");
printf("- 顺序表 -\n");
printf("- a:追加一个节点 i:插入一个节点 -\n");
printf("- d:删除一个节点 e:退出 -\n\n");
ListList(list);
}
linearlist *CreateList() //创建线性顺序表
{
linearlist *list = (linearlist *)malloc(sizeof(linearlist)); //分配空间
list->last = 0; //初始化头节点的值
return list; //返回初始化头节点指针
}
void AppendNode(linearlist *list, int n) //追加节点
{
if(list->last < MAXLISTSIZE) //顺序表不溢出
{
list->data[list->last] = n; //初始化节点值
list->last += 1; //顺序表长度加1
}
}
void InsertNode(linearlist *list, int n, int pos) //插入节点
{
int j;
if (pos < 0 || pos > list->last)
printf("所插入的位置超出顺序表的范围\n");
else
{
for (j=list->last; j>=pos; j--) //逆向遍历顺序表
{
list->data[j+1] = list->data[j]; //元素后移
}
list->data[pos] = n; //指向节点赋值
list->last++; //顺序表长度加1
}
}
void DeleteNode(linearlist *list, int pos)
{
int j;
if ((pos < 0) || (pos > list->last)) //删除位置超出顺序表范围
{
printf("所要删除的位置超出顺序表的范围\n");
}
else
{
for (j=pos; j<list->last; j++)
list->data[j] = list->data[j+1]; //元素前移
list->last--; //顺序表长度减1
}
}
int main(void)
{
int key, pos; //key元素值， pos下标
char ch;
linearlist *list;
list = CreateList();
while(1)
{
Output(list);
printf("请选择：");
ch = getchar();
fflush(stdin); //清除缓存
if (ch == 'a')
{
printf("请输入要追加的数据：");
scanf("%d", &key);
AppendNode(list, key);
}
else if (ch == 'i')
{
printf("请输入要插入的数据的位置：");
scanf("%d", &pos);
printf("请输入要插入的数据：");
scanf("%d", &key);
InsertNode(list, key, pos);
}
else if (ch == 'd')
{
printf("请输入要插入的数据的位置：");
scanf("%d", &pos);
DeleteNode(list, pos);
}
else if (ch == 'e')
exit(0);
Output(list);
fflush(stdin);
}
return 0;
}6、数据结构-线性表-单链表
#include <stdio.h>
#include <stdlib.h>
struct linknode
{
int data;
struct linknode *next;
};
typedef struct linknode LinkNode;
LinkNode *CreateLinkNode()
{
int i;
LinkNode *head, *ptr, *p;
head = (LinkNode *)malloc(sizeof(LinkNode));
if (!head)
{
printf("内存分配失败!\n");
exit(1);
}
printf("请输入第1个数据：");
scanf("%d", &head->data);
head->next = NULL;
ptr = head;
for (i=1; i<5; i++)
{
p = (LinkNode *)malloc(sizeof(LinkNode));
if (!p)
{
printf("内存分配失败!\n");
exit(1);
}
printf("请输入第%d个数据：", i+1);
scanf("%d", &p->data);
ptr->next = p;
p->next = NULL;
ptr = ptr->next; //等价于 ptr = p;
}
return head;
}
void PrintNode(LinkNode *ptr)
{
while (ptr != NULL)
{
printf("%5d", ptr->data);
ptr = ptr->next;
}
printf("\n");
}
LinkNode *FindNode(LinkNode *head, int num)
{
LinkNode *ptr;
ptr = head;
while (ptr != NULL)
{
if (ptr->data == num)
return ptr;
ptr = ptr->next;
}
return ptr;
}
LinkNode *InsertNode(LinkNode *head, LinkNode *ptr, int value)
{
LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode));
if (!newnode)
return NULL;
newnode->data = value;
newnode->next = NULL;
if (ptr == NULL)
{
newnode->next = head;
return newnode;
}
else
{
if (ptr->next == NULL)
ptr->next = newnode;
else
{
newnode->next = ptr->next;
ptr->next = newnode;
}
}
return head;
}
LinkNode *DeleteNode(LinkNode *head, LinkNode *ptr)
{
LinkNode *pre; //指向前一结点
if (ptr == head) //是否是链表的开始
return head->next; //输出第二个结点
else
{
pre = head;
while (pre->next != ptr) //找结点ptr的前结点
{
pre = pre->next;
}
if (ptr->next == NULL) //是否是链表的结束
pre->next = NULL; //最后一个结点
else
pre->next = ptr->next; //中间结点
}
free(ptr); //释放结点内存
return head;
}
void FreeLinkNode(LinkNode *head)
{
LinkNode *ptr;
while (head != NULL)
{
ptr = head;
head = head->next;
free(ptr);
}
}
int main(void)
{
int num, value;
LinkNode *head, *ptr;
head = CreateLinkNode();
PrintNode(head);
printf("请输入要查找的数据：\n");
scanf("%d", &num);
ptr = FindNode(head, num);
if (!ptr)
{
printf("没有找到d\n");
}
else
{
printf("找到啦，\n请输入要插入的数据：\n");
scanf("%d", &value);
head = InsertNode(head, ptr, value);
PrintNode(head);
}
printf("请输入要查找并删除的数据：\n");
scanf("%d", &num);
ptr = FindNode(head, num);
if (!ptr)
{
printf("没有找到！\n");
}
else
{
printf("找到啦！\n");
head = DeleteNode(head, ptr);
PrintNode(head);
}
FreeLinkNode(head);
return 0;
}
7、双指针的妙用
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int NodeVal;
typedef struct LinkNode_t
{
NodeVal val;
struct LinkNode_t *next;
}LinkNode;
//创建链表
LinkNode *createLinkNode(NodeVal *arr, size_t n)
{
//定义头结点、普通结点、尾结点
LinkNode *head = NULL, *node = NULL, *end = NULL;
for (size_t i = 0; i < n; i++)
{
node = (LinkNode *)malloc(sizeof(LinkNode));
if (NULL == head)
{
head = node;
head->val = arr[i];
end = head;
}
else
{
node->val = arr[i];
end->next = node;
end = node;
}
}
end->next = NULL;
return head;
}
//释放资源
void destoryLinkNode(LinkNode *head)
{
LinkNode *pn = NULL;
while ( NULL != head )
{
if (NULL == head->next)
{
free(head);
head = NULL;
}
else
{
pn = head->next->next;
free(head->next);
head->next = pn;
}
}
}
//返回链表的中间结点，如果有两个中间结点，则返回第二个中间结点
LinkNode *findMidNode(LinkNode *head)
{
LinkNode *fast = head;
LinkNode *slow = head;
while ( NULL != fast && NULL != fast->next )
{
fast = fast->next->next;
slow = slow->next;
}
return slow;
}
//链表的中间结点 输出链表中倒数第k个结点
LinkNode *FindKthToTail(LinkNode *head, unsigned int k)
{
if ( NULL == head || 0 == k )
return head;
LinkNode *pFast = head;
LinkNode *pSlow = head;
unsigned int i = 0;
//快指针先移动
while ( i < k - 1 )
{
if (NULL != pFast)
{
pFast = pFast->next;
}
//k大于链表的长度
else
{
return NULL;
}
i++;
}
//快慢指针一起移动
while ( NULL != pFast->next )
{
pSlow = pSlow->next;
pFast = pFast->next;
}
return pSlow;
}
//判断链表是否有环
int hasLoop(LinkNode *head)
{
if (NULL == head)
{
return 0;
}
LinkNode *slow = head;
LinkNode *fast = head->next;
//当快指针到末尾时，无环，结束
while ( NULL != fast && NULL != slow )
{
//快慢相遇，有环
if (fast == slow)
{
return 1;
}
slow = slow->next; //慢指针每次走一步
fast = fast->next;
if (fast != NULL)
{
fast = fast->next;
}
}
return 0;
}
void printLinkNode(LinkNode *head)
{
while ( NULL != head )
{
NULL == head->next ? printf("%d\n", head->val) : printf("%d->", head->val);
head = head->next;
}
}
int main(void)
{
NodeVal arr[] = { 1,2,3,4,5,6,7 };
LinkNode *head = NULL;
head = createLinkNode(arr, sizeof(arr) / sizeof(NodeVal));
printLinkNode(head);
LinkNode *findNode = FindKthToTail(head, 3);
LinkNode *findmNode = findMidNode(head);
if (NULL != findNode)
{
printf("链表倒数第三个节点是： %d\n", findNode->val);
}
if (NULL != findmNode)
{
printf("链表中间结点是： %d\n", findmNode->val);
}
destoryLinkNode(head);
return 0;
}
快慢指针的技巧：
返回链表的中间结点
分析：
>> 快慢指针同时指向头结点，快指针走两步，慢指针走一步
>> 如果长度为偶数，那么快指针为NULL的时候停止，长度为
奇数，那么快指针->next为NULL的时候停止
>> 慢指针指向的位置就是中间结点了
返回链表倒数第k个结点
分析：
>> 快慢指针同时指向头结点
>> 首先快指针移动k-1步，先走到第k个节点
>> 快慢指针同时移动，直到快指针指向末尾，这时快慢指针都走了L-K
>> 慢指针指向的结点就是要寻找的结点
8、顺序队列
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 100 //定义队列最大有多少个
#define datatype char //定义数据类型
//结构体队列
struct queue
{
datatype data[N]; //存放数据的数组
int front; //允许删除的一端称为队头
int rear; //允许插入的一端称为队尾
};
typedef struct queue QUEUE;
//队列接口
void initQUEUE(QUEUE *sq); //初始化顺序队列
int isempty(QUEUE *sq); //判断队列是否为空
datatype gethead(QUEUE *sq); //获取队列最一个元素
void enQUEUE(QUEUE *sq, datatype data); //队列入队
datatype deQUEUE(QUEUE *sq); //队列出队
void showQUEUE(QUEUE *sq); //输出队列
int main(void)
{
QUEUE q1;
initQUEUE(&q1); //初始化队列
char *str = "abcdefg";
char *p = str;
while ( *p != '\0' )
{
enQUEUE(&q1, *p); //字符挨个入队
showQUEUE(&q1); //显示队列所有元素
p++;
}
while ( isempty(&q1) != 1 ) //只要队列不空，就循环
{
printf("\n出队的字符：%c", deQUEUE(&q1)); //打印出队的字符
showQUEUE(&q1);
}
return 0;
}
//队列接口
//初始化顺序队列
void initQUEUE(QUEUE *sq)
{
//实现队列初始化，等价于队列清空
sq->front = sq->rear = 0;
}
//判断队列是否为空
int isempty(QUEUE *sq)
{
//队头与队尾重合，为空
if (sq->front == sq->rear)
{
return 1;
}
else
{
return 0;
}
}
//获取队列最一个元素
datatype gethead(QUEUE *sq)
{
if ( sq->front == sq->rear )
return -1;
//返回第一个结点的数据
return sq->data[sq->front];
}
//队列入队
void enQUEUE(QUEUE *sq, datatype data)
{
if (sq->rear == N)
{
printf("队列已满！\n");
return;
}
sq->data[sq->rear] = data; //入队
sq->rear++; //下标移动
}
//队列出队
datatype deQUEUE(QUEUE *sq)
{
//如果队列为空
if ( sq->front == sq->rear )
return -1;
sq->front++; //删除一个元素，向前移动一个
return sq->data[sq->front - 1]; //返回前一个元素，即删除的元素
}
//输出队列
void showQUEUE(QUEUE *sq)
{
if ( sq->front == sq->rear )
return;
else
{
printf("\nfront = %d, rear = %d\n", sq->front, sq->rear);
//打印队列元素
for (int i = sq->front; i<sq->rear; i++)
{
printf("%c ", sq->data[i]);
}
printf("\n");
}
}9、用类创建链表
#include <iostream>
using namespace std;
class Node
{
private:
int data;
Node *next;
public:
Node(int data)
{
this->data = data;
this->next = NULL;
}
static Node *pHead; //头结点指针
static Node *pTail; //尾结点指针
//向链表尾部加入结点
static void AddNode(int data)
{
if ( pHead == NULL )
{
pHead = new Node(data);
pTail = pHead;
return;
}
pTail->next = new Node(data);
pTail = pTail->next;
}
static void AddNode(Node *node)
{
if ( pHead == NULL )
{
pHead = node;
pTail = pHead;
return;
}
pTail->next = node;
pTail = pTail->next;
}
//根据数据内容删除结点
static bool DeleteNodes(int data)
{
bool flag = false;
if ( pHead == NULL )
{
return flag;
}
//遍历查找符合条件的结点
Node *pTemp = pHead;
if ( pHead->data == data )
{
pTemp = pHead->next;
delete pHead;
pHead = pTemp;
if ( pHead == NULL )
{
return flag;
}
}
Node *pMove = pHead->next;
while ( pMove != NULL )
{
if ( pMove->data == data )
{
pTemp->next = pMove->next;
delete pMove;
pMove = pTemp->next;
}
else //迭代移动指针
{
pMove = pMove->next;
pTemp = pTemp->next;
}
}
return flag;
}
//显示链表结点信息
static void GetNodesMessage()
{
if ( pHead == NULL )
{
cout << "当前链表为空。" << endl;
return;
}
Node *pMove = pHead;
while ( pMove != NULL )
{
cout << pMove->data << "->";
pMove = pMove->next;
}
cout << "NULL" << endl;
}
};
//在类外初始化静态成员变量
Node *Node::pHead = NULL;
Node *Node::pTail = NULL;
int main(void)
{
Node::GetNodesMessage();
int num;
while ( true )
{
cout << "输入要添加结点的数据：-1退出" << endl;
cin >> num;
if ( num != -1 )
{
Node::AddNode(num);
}
else
{
break;
}
system("cls");
Node::GetNodesMessage();
}
Node::GetNodesMessage();
while ( true )
{
cout << "输入要删除结点的数据：-1退出" << endl;
cin >> num;
if ( num != -1 )
{
Node::DeleteNodes(num);
}
else
{
break;
}
system("cls");
Node::GetNodesMessage();
}
Node::GetNodesMessage();
system("pause");
return 0;
}10、用类实现单向链表逆置
#include <iostream>
#include <string>
using namespace std;
typedef class StudentNode
{
private:
StudentNode *pNext;
string m_Name;
int m_Age;
float m_Score;
static StudentNode *pTail, *pHead;
public:
StudentNode(string name, int age, float score)
{
this->m_Name = name;
this->m_Age = age;
this->m_Score = score;
pNext = NULL;
}
//添加结点成员函数
static void AddSN(StudentNode *pSN)
{
if (pHead == NULL)
{
pHead = pSN;
pTail = pHead;
return;
}
pTail->pNext = pSN;
pTail = pTail->pNext;
}
//逆置链表成员函数
static void Reverse()
{
//空链表，返回
if (pHead==NULL)
{
return;
}
//将链表从头部开始解体，重新构成新链表
StudentNode *pTemp = pHead, //改变当前位置结点的指向
*pMove = pHead->pNext; //记录原链表下一个位置结点
pHead->pNext = NULL; //断链
pTail = pHead; //将链表尾部逆置
while ( pMove != NULL )
{
pTemp = pMove;
pMove = pMove->pNext;
pTemp->pNext = pHead;
pHead = pTemp;
}
}
//显示输出链表
static void GetMessage()
{
if (pHead == NULL)
{
cout << "当前链表为空" << endl;
return;
}
StudentNode *pMove = pHead;
cout << "===============================" << endl;
cout << "姓名\t年龄\t成绩" << endl;
cout << "===============================" << endl;
while ( pMove != NULL )
{
cout << pMove->m_Name << "\t"
<< pMove->m_Age << "\t"
<< pMove->m_Score << endl;
pMove = pMove->pNext;
}
}
}SN;
//类外初始化静态成员变量
SN *SN::pHead = NULL;
SN *SN::pTail = NULL;
int main(void)
{
SN::GetMessage();
cout << "创建链表" << endl;
SN::AddSN(new SN("张三", 18, 4.4f));
SN::AddSN(new SN("李四", 17, 4.5f));
SN::AddSN(new SN("王五", 19, 5.0f));
SN::GetMessage();
cout << endl << "逆转链表" << endl;
SN::Reverse();
SN::GetMessage();
cout << endl << "向新链表中添加结点" << endl;
SN::AddSN(new SN("赵六", 18, 4.7f));
SN::GetMessage();
system("pause");
return 0;
}
2804
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
