LinkList(no heaer) 

 1 #pragma once
 2 
 3 typedef int Type;
 4 
 5 typedef struct Node{
 6     Type data;
 7     struct Node *next;
 8 } Node, *NodePtr;
 9 
10 NodePtr Find(NodePtr first, int i); 
11 NodePtr InsertNode(NodePtr first, int i, Type d);
12 NodePtr DeleteNode(NodePtr first, int i);
13 NodePtr CreateList(int n);
14 NodePtr Reverse1(NodePtr first); //迭代反转
15 NodePtr Reverse2(NodePtr first); //栈反转
16 NodePtr Reverse3(NodePtr first); //递归反转
17 NodePtr FindBackIndex(NodePtr first, int n); //Find倒数n个节点
18 int Transfer(NodePtr first, void (*handle)(NodePtr));
  1 #include <stdlib.h>
  2 #include <stdio.h>
  3 #include "list.h"
  4 #include "LinkStack.h"
  5 
  6 static NodePtr CreateNode(Type d)
  7 {
  8     NodePtr node;
  9 
 10     node = (NodePtr)malloc(sizeof(*node));
 11     if (NULL == node)
 12    　　 return NULL;
 13 
 14     node->data = d;
 15     node->next = NULL;
 16 
 17     return node;
 18 }
 19 
 20 NodePtr Find(NodePtr first, int i)
 21 {
 22     int j;
 23     NodePtr node;
 24 
 25     if (i <= 0)
 26     　　return NULL;
 27 
 28     node = first;
 29     for (j = 1; node->next != NULL && j < i; j++)
 30     　　node = node->next;
 31 
 32     return node;
 33 }
 34 
 35 NodePtr InsertNode(NodePtr first, int i, Type d)
 36 {
 37     NodePtr node, pre;
 38 
 39     node = CreateNode(d);
 40     if (NULL == node)
 41     　　return NULL;
 42 
 43     if (0 == i) {
 44     　　node->next = first;
 45     　　first = node;
 46     　　return first;
 47     }
 48 
 49     pre = Find(first, i);
 50     node->next = pre->next;
 51     pre->next = node;
 52 
 53     return first;
 54 }
 55 
 56 NodePtr DeleteNode(NodePtr first, int i)
 57 {
 58     NodePtr pre, node;
 59 
 60     if (0 == i) {
 61     　　node = first;
 62     　　first = first->next;
 63     　　free(node);
 64     　　return first;
 65     }
 66 
 67     pre = Find(first, i - 1);
 68     node = pre->next;
 69     pre->next = node->next;
 70     free(node);
 71 
 72     return first;
 73 }
 74 
 75 NodePtr CreateList(int n)
 76 {
 77     int i;
 78     NodePtr first = NULL;
 79 
 80     for (i = 0; i < n; ++i)
 81     　　first = InsertNode(first, 0, i);
 82 
 83     return first;
 84 }
 85 
 86 NodePtr Reverse1(NodePtr first)
 87 {
 88     NodePtr pre, cur, last;
 89 
 90     pre = NULL;
 91     cur = first;
 92     while (cur) {
 93     　　last = cur->next;
 94     　　cur->next = pre;
 95 
 96     　　pre = cur;
 97     　　cur = last;
 98     }
 99 
100     return pre;
101 }
102 
103 NodePtr Reverse2(NodePtr first)
104 {
105     NodePtr r_first;
106     NodePtr p, cur;
107     LStack stk;
108 
109     r_first = NULL;
110 
111     InitStack(&stk);
112 
113     while (first) {
114     　　Push(&stk, first);
115     　　first = first->next;
116     }
117 
118     if(Pop(&stk, &p))
119     　　r_first = p;
120 
121     cur = r_first;
122     while (Pop(&stk, &p)) {
123     　　cur->next = p;
124     　　cur = p;
125     }
126 
127     cur->next = NULL;
128     return r_first;
129 }
130 
131 NodePtr Reverse3(NodePtr first)
132 {
133     NodePtr cur, last;
134 
135     cur = first;
136     if ( cur == NULL || cur->next == NULL)
137     　　return cur;
138     while (cur->next->next != NULL)
139     　　cur = cur->next;
140 
141     last = cur->next;
142     last->next = cur;
143     cur->next = NULL;
144 
145     Reverse3(first);
146 
147     first = last;
148 
149     return first;
150 }
151 
152 NodePtr FindBackIndex(NodePtr first, int n)
153 {
154     int i = 0;
155     NodePtr left, right;
156     left = first;
157     right = first;
158 
159     while (i++ < n && right != NULL)
160     　　right = right->next;
161 
162     while (right != NULL) {
163     　　right = right->next;
164     　　left = left->next;
165     }
166 
167     return left;
168 }
169 
170 int Transfer(NodePtr first, void (*handle)(NodePtr))
171 {
172     NodePtr node;
173 
174     if (NULL == handle)
175     return -1;
176 
177     while (first) {
178     　　node = first;
179     　　first = first->next;
180     　　handle(node);
181     }
182 
183     return 0;
184 }
 1 #include <stdlib.h>
 2 #include <stdio.h>
 3 #include "list.h"
 4 
 5 void show(NodePtr node)
 6 {
 7     printf("%d ", node->data);
 8 }
 9 
10 void delete(NodePtr node)
11 {
12     free(node);
13 }
14 
15 int main(int argc, char **argv)
16 {
17     NodePtr first, node;
18 
19     first = CreateList(10);
20     Transfer(first, show);
21     putchar('\n');
22 
23     first = DeleteNode(first, 0);
24     Transfer(first, show);
25     putchar('\n');
26 
27     first = DeleteNode(first, 9);
28     Transfer(first, show);
29     putchar('\n');
30 
31     first = DeleteNode(first, 4);
32     Transfer(first, show);
33     putchar('\n');
34 
35     first = Reverse1(first);
36     Transfer(first, show);
37     putchar('\n');
38 
39     first = Reverse2(first);
40     Transfer(first, show);
41     putchar('\n');
42 
43     first = Reverse3(first);
44     Transfer(first, show);
45     putchar('\n');
46 
47     node = FindBackIndex(first, 3);
48     show(node);
49     putchar('\n');
50 
51     Transfer(first, delete);
52     Transfer(first, show);
53     putchar('\n');
54 
55     return 0;
56 }

posted on 2012-09-11 16:55  robin.he  阅读(199)  评论(0)    收藏  举报

导航