#include<stdio.h>
#include<stdlib.h>
#define max 5
typedef struct List
{
int val;
struct List *next;
}list;
list *head,*last,*p;
list* reverse(list *head)
{
list *beg=NULL,*mid=head,*end=mid->next;
while(end)
{
mid->next=beg;
beg=mid;
mid=end;
end=end->next;
}
mid->next=beg;
head=mid;
return head;
}
int main()
{
head=NULL;
for(int i=0;i<max;i++)
{
p=(list*)malloc(sizeof(list));
scanf("%d",&p->val);
p->next=NULL;
if(head==NULL)
{
head=p;
last=p;
}
else
{
last->next=p;
last=p;
}
}
list *nhead=reverse(head);
while(nhead)
{
printf("%d ",nhead->val);
nhead=nhead->next;
}
printf("\n");
while(head)
{
printf("%d ",head->val);
head=head->next;
}
}
单链表的创建、反转，以及打印反转后的节点、创建后的节点
为什么打印创建后的节点只能打印出一个value
修改如下，改动处见注释，供参考：
#include <stdio.h>
#include <stdlib.h>
#define max 5
typedef struct List
{
int val;
struct List* next;
}list;
list* head, * last, * p;
list* reverse(list* head)
{
list* beg = NULL, * mid = head, * end = head; //mid->next; 修改
head = NULL; //修改
while (end)
{
beg = end; //修改
end = end->next; //修改
beg->next = head;//修改
head = beg; //修改
//beg = mid; //修改
//mid = end;
//end = end->next;
}
//mid->next = beg; //修改
//head = mid; //修改
return head;
}
int main()
{
head = NULL;
for (int i = 0; i < max; i++)
{
p = (list*)malloc(sizeof(list));
scanf("%d", &p->val);
p->next = NULL;
if (head == NULL)
{
head = p;
last = p;
}
else
{
last->next = p;
last = p;
}
}
list* nhead = reverse(head);
head = nhead; //修改
while (nhead)
{
printf("%d ", nhead->val);
nhead = nhead->next;
}
printf("\n");
while (head)
{
printf("%d ", head->val);
head = head->next;
}
return 0;
}
数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633
首先，让我们来解决问题的第一部分：如何创建一个单向链表。
创建单向链表的步骤如下： 1. 定义一个链表节点的结构体，包含一个数据域和一个指向下一个节点的指针。 2. 创建头节点，并将头节点的指针指向空值，表示链表为空。 3. 通过动态内存分配方式，创建链表的其他节点，并将节点的指针链接到前一个节点的指针域中，形成链表。
具体的代码如下所示：
#include <stdio.h>
#include <stdlib.h> // 包含动态内存分配所需的函数
// 定义链表节点的结构体
typedef struct Node {
int data;
struct Node *next;
} Node;
// 创建一个空链表
Node* createLinkedList() {
Node *head = (Node*)malloc(sizeof(Node)); // 创建头节点
head->next = NULL; // 头节点的指针指向空值
return head;
}
// 在链表末尾插入节点
void insertNode(Node *head, int value) {
Node *newNode = (Node*)malloc(sizeof(Node)); // 新建一个节点
newNode->data = value; // 新节点的数据域赋值
newNode->next = NULL; // 新节点的指针指向空值
Node *temp = head; // 临时指针指向头节点
while (temp->next != NULL) { // 遍历链表找到最后一个节点
temp = temp->next;
}
temp->next = newNode; // 最后一个节点的指针指向新节点
}
// 反转链表
Node* reverseLinkedList(Node *head) {
Node *prev = NULL; // 前一个节点的指针
Node *current = head->next; // 当前节点的指针
Node *next = NULL; // 下一个节点的指针
while (current != NULL) {
next = current->next; // 获取下一个节点的指针
current->next = prev; // 将当前节点的指针指向前一个节点
prev = current; // 前一个节点的指针指向当前节点
current = next; // 当前节点的指针指向下一个节点
}
// 修改头节点的指针
head->next = prev;
return head;
}
// 打印链表的所有节点
void printLinkedList(Node *head) {
Node *temp = head->next; // 跳过头节点，指向第一个节点
while (temp != NULL) {
printf("%d ", temp->data); // 打印节点的数据域
temp = temp->next; // 移动到下一个节点
}
printf("\n");
}
int main() {
// 创建一个空链表
Node *head = createLinkedList();
// 在链表末尾插入节点
insertNode(head, 1);
insertNode(head, 2);
insertNode(head, 3);
insertNode(head, 4);
// 打印原始链表
printf("原始链表的节点: ");
printLinkedList(head);
// 反转链表
head = reverseLinkedList(head);
// 打印反转后的链表
printf("反转后的链表的节点: ");
printLinkedList(head);
return 0;
}
上述代码首先定义了一个链表节点的结构体，包含一个数据域和一个指向下一个节点的指针。然后使用createLinkedList函数创建了一个空链表（只包含头节点）。使用insertNode函数在链表末尾插入节点。reverseLinkedList函数用于反转链表。printLinkedList函数用于打印链表的所有节点。
接下来，让我们解决问题的第二部分：如何打印出反转后的节点和创建后的所有节点。
在上述代码中，已经编写了printLinkedList函数用于打印链表的所有节点。所以，只需要在适当的位置调用该函数即可。具体的代码如下所示：
// 打印原始链表
printf("原始链表的节点: ");
printLinkedList(head);
// 反转链表
head = reverseLinkedList(head);
// 打印反转后的链表
printf("反转后的链表的节点: ");
printLinkedList(head);
在主函数中，首先使用printLinkedList函数打印原始链表的所有节点，然后调用reverseLinkedList函数反转链表，最后再次调用printLinkedList函数打印反转后的链表的所有节点。
通过以上步骤，您可以创建一个单向链表，进行反转操作，并打印出反转后的节点和创建后的所有节点。