带头结点的双向链表操作

本题目要求读入一系列整数，依次插入到双向循环链表的头部和尾部，然后顺序和逆序输出链表。

链表节点类型可以定义为

typedef int DataType;
typedef struct LinkedNode{
    DataType data;
    struct LinkedNode *prev;
    struct LinkedNode *next;
}LinkedNode;
1
2
3
4
5
6

链表类型可以定义为

typedef struct LinkedList{
  int length; /* 链表的长度 */
  LinkedNode head; /* 双向循环链表的头节点 */
}LinkedList;
1
2
3
4

初始化链表的函数可声明为

void init_list(LinkedList *list);
1

分配节点的函数可声明为

LinkedNode *alloc_node(DataType data);
1

头部插入的函数可声明为

void push_front(LinkedList *list, DataType data);
1

尾部插入的函数可声明为

void push_back(LinkedList *list, DataType data);
1

顺序遍历的函数可声明为

void traverse(LinkedList *list);
1

逆序遍历的函数可声明为

void traverse_back(LinkedList *list);
1

输入格式:

输入一行整数（空格分隔），以-1结束。

输出格式:

第一行输出链表顺序遍历的结果，第二行输出逆序遍历的结果。

输入样例:

在这里给出一组输入。例如：

1 2 3 4 5 6 -1
1

输出样例:

5 3 1 2 4 6
6 4 2 1 3 5
1
2

带来一个我的解法~：

#include 
using namespace std;
typedef int DataType;
typedef struct LinkedNode
{
	DataType data;
	struct LinkedNode *prev;
	struct LinkedNode *next;
} LinkedNode;
typedef struct LinkedList
{
	int length;		  /* 链表的长度 */
	LinkedNode *head; /* 双向循环链表的头节点 */
} LinkedList;

void init_list(LinkedList *list);
void init_list(LinkedList *list)
{
	list->length = 0;
	list->head = new LinkedNode;
	list->head->next = NULL;
	list->head->prev = NULL;
}
LinkedNode *alloc_node(DataType data);
LinkedNode *alloc_node(DataType data)
{
	LinkedNode *l;
	l = new LinkedNode;
	l->data = data;
	l->next = NULL;
	l->prev = NULL;
	return l;
}
void push_front(LinkedList *list, DataType data);
void push_back(LinkedList *list, DataType data);
void traverse(LinkedList *list);
void traverse_back(LinkedList *list);
void test01();
void test01()
{
	LinkedList list, *pList = &list;
	init_list(pList);
	int data;
	int flag = 0;
	while (1)
	{
		cin >> data;
		if (data == -1)
		{
			break;
		}
		if (flag == 1)
		{
			push_back(pList, data);
			flag = 0;
		}
		else
		{
			push_front(pList, data);
			flag = 1;
		}
	}

	traverse(pList);
	traverse_back(pList);
}
void push_front(LinkedList *list, DataType data)
{
	LinkedNode *p;
	p = alloc_node(data);
	LinkedNode *t;
	t = list->head;
	while (t->prev)
	{
		t = t->prev;
	}

	t->prev = p;
	p->next = t;
}
void push_back(LinkedList *list, DataType data)
{
	LinkedNode *p;
	p = alloc_node(data);
	LinkedNode *t;
	t = list->head;
	while (t->next)
	{
		t = t->next;
	}

	t->next = p;
	p->prev = t;
}
void traverse(LinkedList *list)
{
	LinkedNode *t;
	t = list->head;
	int count = 0;
	while (t->prev)
	{
		t = t->prev;
	}
	while (t)
	{
		if (t == list->head)
		{
			t = t->next;
		}

		if (count == 0)
		{
			cout << t->data;
			count++;
		}
		else
		{
			cout << " " << t->data;
		}

		t = t->next;
	}
	cout << endl;
}
void traverse_back(LinkedList *list)
{
	LinkedNode *t;
	int count = 0;
	t = list->head;
	while (t->next)
	{
		t = t->next;
	}
	while (t)
	{
		if (t == list->head)
		{
			t = t->prev;
		}

		if (count == 0)
		{
			cout << t->data;
			count++;
		}
		else
		{
			cout << " " << t->data;
		}

		t = t->prev;
	}
	cout << endl;
}
int main()
{
	test01();
	system("pause");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160