数据结构学习第十天

  1 #include<stdio.h>
  2 #include<malloc.h>
  3 typedef struct Node* PtrToNode;
  4 struct Node
  5 {
  6     int Data;
  7     PtrToNode Pred;   //前驱
  8     PtrToNode Succ;   //后继
  9 };
 10 PtrToNode Header;//头哨兵
 11 PtrToNode Trailer;//尾哨兵      //前面写的双向链表只给 头部加了一个表头(哑节点)  现在给尾部也加一个哑节点
 12 int size;      //规模
 13 
 14 void Init();   //初始化
 15 PtrToNode InsertPred(int Element);   //前插入
 16 PtrToNode InsertSucc(int Element);   //后插入
 17 int Size();        //返回列表当前规模(节点总数)
 18 PtrToNode First() { return Header->Succ; }   //返回首节点位置
 19 PtrToNode Last()  { return Trailer->Pred;}     //返回末节点位置
 20 PtrToNode InsertAsFirst(int Element);  //将元素E当首节点插入
 21 PtrToNode InsertAsLast(int Element) { InsertBefore(Trailer, Element); }   //将元素E当末节点插入
 22 PtrToNode InsertBefore(PtrToNode P, int Element);   //将元素E当作P的前驱元插入
 23 PtrToNode InsertAfter(PtrToNode P, int Element);   //将元素E当作P的后驱元插入
 24 int Remove(PtrToNode P);    //删除节点 返回删除的数据
 25 int Disordered();        //判断所有节点是否有按非降序排列
 26 void Sort();            //调整各节点的位置 使之按非降序排列
 27 PtrToNode Find(int Element,int n,PtrToNode P); //查找目标元素E(从P(不包括)到P节点前n个元素) 失败时返回NULL 
 28 PtrToNode Search(int Element,int n,PtrToNode P);  //在P节点前的n个元素中 查找E 返回不大于E且秩最大的节点
 29 int DeDuplicate();     //剔除重复元素
 30 int Uniquify();        //剔除重复元素
 31 void Traverse();        //遍历列表
 32 
 33 
 34 
 35 void Init()
 36 {
 37     Header = (PtrToNode)malloc(sizeof(Node));
 38     Trailer = (PtrToNode)malloc(sizeof(Node));
 39     Header->Succ = Trailer; Header->Pred = NULL;
 40     Trailer->Pred = Header; Trailer->Succ = NULL;
 41     size = 0;
 42 }
 43 
 44 //无序列表
 45 int VisitByRank(int r)   //寻秩序访问  效率低下
 46 {
 47     PtrToNode P =First();   //首节点出发
 48     while (r--)
 49     {
 50         P = P->Succ;
 51     }
 52     return P->Data;
 53 }
 54 
 55 PtrToNode Find(int Element, int n, PtrToNode P)  //查找目标元素E(从P(不包括)到P节点前n个元素) 失败时返回NULL 
 56 {
 57     /*PtrToNode Ptr = P;
 58     for (int i = 1; i < n + 1; i++)
 59     {
 60         Ptr = Ptr->Pred;
 61         if (Ptr->Data == Element)
 62             return Ptr;
 63     }
 64     return NULL;*/
 65     while (n--)
 66         if (Element ==(P = P->Succ)->Data) return P;
 67     return NULL;
 68 }
 69 
 70 PtrToNode InsertBefore(PtrToNode P, int Element)   //将元素E当作P的前驱元插入
 71 {
 72     PtrToNode Ptr = (PtrToNode)malloc(sizeof(Node));
 73     Ptr->Data = Element;
 74     Ptr->Succ = P; Ptr->Pred = P->Pred;
 75     P->Pred = Ptr; Ptr->Pred->Succ = Ptr;
 76     size++;
 77 }
 78 PtrToNode InsertAfter(PtrToNode P, int Element)   //将元素E当作P的后继元插入
 79 {
 80     PtrToNode Ptr = (PtrToNode)malloc(sizeof(Node));
 81     Ptr->Data = Element;
 82     Ptr->Pred = P; Ptr->Succ = P->Succ;
 83     P->Succ = Ptr; Ptr->Succ->Pred = Ptr;
 84     size++;
 85 }
 86 //复制 
 87 void CopyNodes(PtrToNode P, int n)
 88 {
 89     Init();   //创造一个新的首尾节点
 90     while (n--)
 91     {
 92         InsertAsLast(P->Data);
 93         P = P->Succ;
 94     }
 95 }
 96 
 97 int Remove(PtrToNode P)    //删除节点
 98 {
 99     int Element = P->Data;   //备份数据
100     P->Pred->Succ = P->Succ;
101     P->Succ->Pred = P->Pred;
102     free(P);
103     size--;
104     return Element;     //返回删除节点
105 }
106 
107 int Delete()
108 {
109     /*PtrToNode P1, P2;
110     P1=P2=Header->Succ;
111     while (size--)
112     {
113         P2 = P1->Succ;
114         Remove(P1);      //这里写错了 如果按照我的想法应该用free
115         P1 = P2;
116     }
117     free(Header);
118     free(Trailer);*/  //憨憨博主的做法   这部分写的有问题 remove 会对size进行改变
119     int OldSize = size;
120     while (size)
121     {
122         Remove(Header->Succ);
123     }
124     free(Header);
125     free(Trailer);
126     return OldSize;
127 }
128 
129 int DeDuplicate()
130 {
131     if (size < 2) return 0;    //平凡情况
132     int OldSize = size;
133     PtrToNode P = First();
134     int r = 1;
135     while (Trailer!=(P=P->Succ))
136     {
137         PtrToNode Q = Find(P->Data, r, P);    
138         Q ? Remove(Q) : r++;            //删除前面的元素 如果删除后面的会出错 因为此时P为NULL
139     }
140     return OldSize - size;
141 }
142 
143 //有序列表
144 int Uniquify()      //O(n)
145 {
146     /*if (size < 2) return 0;    //平凡情况
147     int OldSize = size;
148     PtrToNode P1, P2;
149     P1 = First(); P2 = P1->Succ;
150     while (Trailer!=P2)
151     {
152         if (P1->Data == P2->Data)
153         {
154             Remove(P2);
155             P2 = P1->Succ;
156         }
157         else
158         {
159             P1 = P2;
160             P2 = P1->Succ;
161         }
162     }
163     return OldSize - size;*/
164     //简化
165     if (size < 2) return 0;    //平凡情况
166     int OldSize = size;
167     PtrToNode P1, P2;
168     P1 = First();
169     while (Trailer!=(P2=P1->Succ))
170     {
171         if (P1->Data!=P2->Data)
172             P1 = P2;
173         else
174             Remove(P2);
175     }
176     return OldSize - size;
177 }
178 
179 PtrToNode Search(int Element, int n, PtrToNode P) //在P节点前的n个元素中 查找E 返回不大于E且秩最大的节点  为其它接口使用提供了方便
180 {
181     while (0<=n--)       //等于0的情况 是为了处理在P节点前的n个元素中 没有查找到 返回P前第n+1个元素
182     {
183         if (Element >= (P = P->Pred)->Data)
184             break;
185     }
186     return P;
187 }
188 
189 //排序算法
190 
191 //选择排序         //O(n^2)
192 void SwapElement(PtrToNode P1, PtrToNode P2)    //交换两个节点的元素
193 {
194     int Element = P1->Data;
195     P1->Data = P2->Data;
196     P1->Data = Element;
197 }
198 PtrToNode SelectMax(PtrToNode P, int n)
199 {
200     PtrToNode Max = P;
201     for (PtrToNode Cur = P; n > 1; n--)
202     {
203         if (Max->Data <= (Cur = Cur->Succ)->Data)    //元素相同时也要返回后面的元素
204             Max = Cur;
205     }
206     return Max;
207 }
208 void SelectSort(PtrToNode P, int n)    //将P后n个元素进行排序
209 {
210     PtrToNode head = P->Pred;
211     PtrToNode tail = P;
212     for (int i = 0; i < n; i++) tail = tail->Succ;
213     while (n>1)
214     {
215         //InsertBefore(tail, Remove(SelectMax(head->Succ, n)));
216         SwapElement(SelectMax(head->Succ, n),tail->Pred);
217         tail = tail->Pred;
218         n--;
219         /*优化
220         PtrToNode Max = SelectMax(head->Succ, n);
221         if (tail->Pred != Max)
222             SwapElement(Max, tail->Pred);
223         tail = tail->Pred;
224         n--;*/
225     }
226 }
227 
228 //插入排序            最好O(n)  最坏O(n^2)
229 void InsertionSort(PtrToNode P,int n) //从位置P开始 到之后的n个元素
230 {
231     for (int r = 0; r < n; r++)
232     {
233         InsertAfter(Search(P->Data, r, P), P->Data);
234         P = P->Succ;
235         Remove(P->Pred);
236     }
237 }