数据结构总结

1 #define MAXSIZE 20    
2 typedef int ElemType;
3 typedef struct
4 {
5 ElemType data[MAXSIZE];
6 int length;    // 线性表当前长度
7 } SqList;

 1 #define OK 1
 2 #define ERROR 0
 3 #define TRUE 1
 4 #define FALSE 0
 5 
 6 typedef int Status;
 7 
 8 // Status 是函数的类型，其值是函数结果状态代码，如OK等。
 9 // 初始条件：顺序线性表L已存在，1 <= i <= ListLength(L)
10 // 操作结果：用e返回L中第i个数据元素的值。
11 
12 Status GetElem(SqList L, int i, ElemType *e)
13 {
14     if( L.length==0 || i<1 || i>L.length )
15     {
16         return ERROR;
17     }
18     *e = L.data[i-1];
19 
20     return OK;
21 }

 1 /* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L)。 */
 2 /* 操作结果：在L中第i个位置之前插入新的数据元素e，L长度+1。*/
 3 
 4 Status ListInsert(SqList *L, int i, ElemType e)
 5 {
 6     int k;
 7 
 8     if( L->length == MAXSIZE )  // 顺序线性表已经满了
 9     {
10         return ERROR;
11     }
12     if( i<1 || i>L->length+1)   // 当i不在范围内时
13     {
14         return ERROR;
15     }
16     if( i <= L->length )   // 若插入数据位置不在表尾
17     {
18         /* 将要插入位置后数据元素向后移动一位 */
19         for( k=L->length-1; k >= i-1; k-- )
20         {
21             L->data[k+1] = L->data[k];
22         }
23     }
24 
25     L->data[i-1] = e;  // 将新元素插入
26     L->length++;
27 
28     return OK;
29 }

 1 /* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
 2 /* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度-1 */
 3 Status ListDelete(SqList *L, int i, ElemType *e)
 4 {
 5     int k;
 6 
 7     if( L->length == 0 )
 8     {
 9         return ERROR;
10     }
11     if( i<1 || i>L->length )
12     {
13         return ERROR;
14     }
15 
16     *e = L->data[i-1];
17 
18     if( i < L->length )
19     {
20         for( k=i; k < L->length; k++ )
21         {
22             L->data[k-1] = L->data[k];
23         }
24     }
25 
26     L->length--;
27 
28     return OK;
29 }

1 typedef struct Node
2 {
3 ElemType data;      // 数据域
4 struct Node* Next;  // 指针域
5 } Node;
6 typedef struct Node* LinkList;

 1 /* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
 2 /* 操作结果：用e返回L中第i个数据元素的值 */
 3 
 4 Status GetElem( LinkList L, int i, ElemType *e )
 5 {
 6     int j;
 7     LinkList p;
 8 
 9     p = L->next;
10     j = 1;
11 
12     while( p && j<i )
13     {
14         p = p->next;
15         ++j;
16     }
17 
18     if( !p || j>i )
19     {
20         return ERROR;
21     }
22 
23     *e = p->data;
24 
25     return OK;
26 }

 1 /* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
 2 /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
 3 
 4 Status ListInsert(LinkList *L, int i, ElemType e)
 5 {
 6     int j;
 7     LinkList p, s;
 8 
 9     p = *L;
10     j = 1;
11 
12     while( p && j<i )   // 用于寻找第i个结点
13     {
14         p = p->next;
15         j++;
16     }
17 
18     if( !p || j>i )
19     {
20         return ERROR;
21     }
22 
23     s = (LinkList)malloc(sizeof(Node));
24     s->data = e;
25 
26     s->next = p->next;
27     p->next = s;
28 
29     return OK;
30 }

 1 /* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
 2 /* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度-1 */
 3 
 4 Status ListDelete(LinkList *L, int i, ElemType *e)
 5 {
 6     int j;
 7     LinkList p, q;
 8 
 9     p = *L;
10     j = 1;
11 
12     while( p->next && j<i )
13     {
14         p = p->next;
15         ++j;
16     }
17 
18     if( !(p->next) || j>i )
19     {
20         return ERROR;
21     }
22 
23     q = p->next;
24     p->next = q->next;
25 
26     *e = q->data;
27     free(q);
28 
29     return OK;
30 }

 1 /* 头插法建立单链表示例 */
 2 
 3 void CreateListHead(LinkList *L, int n)
 4 {
 5     LinkList p;
 6     int i;
 7 
 8     srand(time(0));   // 初始化随机数种子
 9 
10     *L = (LinkList)malloc(sizeof(Node));
11     (*L)->next = NULL;
12 
13     for( i=0; i < n; i++ )
14     {
15         p = (LinkList)malloc(sizeof(Node));  // 生成新结点
16         p->data = rand()%100+1;
17         p->next = (*L)->next;
18         (*L)->next = p;
19     }
20 }

 1 /* 尾插法建立单链表演示 */
 2 
 3 void CreateListTail(LinkList *L, int n)
 4 {
 5     LinkList p, r;
 6     int i;
 7 
 8     srand(time(0));
 9     *L = (LinkList)malloc(sizeof(Node));
10     r = *L;
11 
12     for( i=0; i < n; i++ )
13     {
14         p = (Node *)malloc(sizeof(Node));
15         p->data = rand()%100+1;
16         r->next = p;
17         r = p;                 // 备注：初学者可能很难理解这句，重点解释。
18     }
19 
20     r->next = NULL;
21 }

 1 Status ClearList(LinkList *L)
 2 {
 3     LinkList p, q;
 4 
 5     p = (*L)->next;
 6 
 7     while(p)
 8     {
 9         q = p->next;
10         free(p);
11         p = q;
12     }
13 
14     (*L)->next = NULL;
15 
16     return OK;
17 }

1 #define MAXSIZE 1000
2 typedef struct
3 {
4 ElemType data;  // 数据
5 int cur;        // 游标（Cursor）
6 } Component, StaticLinkList[MAXSIZE];

 1 Status InitList(StaticLinkList space)
 2 {
 3 int i;
 4 for( i=0; i < MAXSIZE-1; i++ )
 5 space[i].cur = i + 1;
 6 
 7 space[MAXSIZE-1].cur = 0;
 8 
 9 return OK;
10 }

1 int Malloc_SLL(StaticLinkList space)
2 {
3 int i = space[0].cur;
4 if( space[0].cur )
5 space[0].cur = space[i].cur;
6    // 把它的下一个分量用来作为备用。
7 return i;
8 }

 1 /* 在静态链表L中第i个元素之前插入新的数据元素e */
 2 
 3 Status ListInsert( StaticLinkList L, int i, ElemType e )
 4 {
 5     int j, k, l;
 6 
 7     k = MAX_SIZE - 1;    // 数组的最后一个元素
 8     if( i<1 || i>ListLength(L)+1 )
 9     {
10         return ERROR;
11     }
12 
13     j = Malloc_SLL(L);
14     if( j )
15     {
16         L[j].data = e;
17         for( l=1; l <= i-1; l++ )
18         {
19             k = L[k].cur;
20         }
21         L[j].cur = L[k].cur;
22         L[k].cur = j;
23 
24         return OK;
25     }
26 
27     return ERROR;
28 }

 1 /* 删除在L中的第i个数据元素 */
 2 Status ListDelete(StaticLinkList L, int i)
 3 {
 4     int j, k;
 5 
 6     if( i<1 || i>ListLength(L) )
 7     {
 8         return ERROR;
 9     }
10 
11     k = MAX_SIZE - 1;
12 
13     for( j=1; j <= i-1; j++ )
14     {
15         k = L[k].cur;    // k1 = 1, k2 = 5
16     }
17 
18     j = L[k].cur;        // j = 2
19     L[k].cur = L[j].cur;
20 
21     Free_SLL(L, j);
22 
23     return OK;
24 }
25 
26 /* 将下标为k的空闲结点回收到备用链表 */
27 void Free_SLL(StaticLinkList space, int k)
28 {
29     space[k].cur = space[0].cur;
30     space[0].cur = k;
31 }
32 
33 /* 返回L中数据元素个数 */
34 int ListLength(StaticLinkList L)
35 {
36     int j = 0;
37     int i = L[MAXSIZE-1].cur;
38 
39     while(i)
40     {
41         i = L[i].cur;
42         j++;
43     }
44 
45     return j;
46 }

 1 /*初始化循环链表*/
 2 void ds_init(node **pNode)
 3 {
 4     int item;
 5     node *temp;
 6     node *target;
 7 
 8     printf("输入结点的值，输入0完成初始化\n");
 9 
10     while(1)
11     {
12         scanf("%d", &item);
13         fflush(stdin);
14 
15         if(item == 0)
16             return;
17 
18         if((*pNode) == NULL)
19         { /*循环链表中只有一个结点*/
20             *pNode = (node*)malloc(sizeof(struct CLinkList));
21             
22             if(!(*pNode))
23                 exit(0);
24             
25             (*pNode)->data = item;
26             (*pNode)->next = *pNode;
27         }
28         else
29         {
30             /*找到next指向第一个结点的结点*/
31             for(target = (*pNode); target->next != (*pNode); target = target->next)
32                 ;
33 
34             /*生成一个新的结点*/
35             temp = (node *)malloc(sizeof(struct CLinkList));
36 
37             if(!temp)
38                 exit(0);
39 
40             temp->data = item;
41             temp->next = *pNode;
42             target->next = temp;
43         }
44     }
45 }

 1 /*链表存储结构的定义*/
 2 typedef struct CLinkList
 3 {
 4     int data;
 5     struct CLinkList *next;
 6 }node;
 7 
 8 /*插入结点*/
 9 /*参数：链表的第一个结点，插入的位置*/
10 void ds_insert(node **pNode , int i)
11 {
12     node *temp;
13     node *target;
14     node *p;
15     int item;
16     int j = 1;
17 
18     printf("输入要插入结点的值:");
19     scanf("%d", &item);
20 
21     if(i == 1)
22     { //新插入的结点作为第一个结点
23         temp = (node *)malloc(sizeof(struct CLinkList));
24 
25         if(!temp)
26             exit(0);
27 
28         temp->data = item;
29 
30         /*寻找到最后一个结点*/
31         for(target = (*pNode); target->next != (*pNode); target = target->next)
32             ;
33 
34         temp->next = (*pNode);
35         target->next = temp;
36         *pNode = temp;
37     }
38     else
39     {
40         target = *pNode;
41 
42         for( ; j < (i-1); ++j )
43         {
44             target = target->next;
45         }  
46         
47         // target指向第三个元素的
48         
49         temp = (node *)malloc(sizeof(struct CLinkList));
50 
51         if(!temp)
52             exit(0);
53 
54         temp->data = item;
55         
56         p = target->next;
57         target->next = temp;
58         temp->next = p;
59     }
60 }

 1 /*删除结点*/
 2 void ds_delete(node **pNode, int i)
 3 {
 4     node *target;
 5     node *temp;
 6     int j = 1;
 7 
 8     if(i == 1)
 9     { //删除的是第一个结点
10         /*找到最后一个结点*/
11         for(target = *pNode; target->next != *pNode;target = target->next)
12             ;
13 
14         temp = *pNode;
15         *pNode = (*pNode)->next;
16         target->next = *pNode;
17         free(temp);
18     }
19     else
20     {
21         target = *pNode;
22 
23         for( ; j < i-1; ++j)
24         {
25             target = target->next;
26         }
27         
28         temp = target->next;
29         target->next = temp->next;
30         free(temp);
31     }
32 }

 1 /*返回结点所在位置*/
 2 int ds_search(node *pNode, int elem)
 3 {
 4     node *target;
 5     int i = 1;
 6 
 7     for(target = pNode; target->data != elem && target->next != pNode; ++i)
 8     {
 9         target = target->next;
10     }
11     
12     if(target->next == pNode) /*表中不存在该元素*/
13         return 0;
14     else
15         return i;
16 }

1 typedef struct DualNode
2 {
3 ElemType data;
4 struct DualNode *prior;  //前驱结点
5 struct DualNode *next;   //后继结点
6 } DualNode, *DuLinkList;

1 s->next = p;    
2 s->prior = p->prior;    
3 p->prior->next = s;    
4 p->prior = s;

1 p->prior->next = p->next;
2 p->next->prior = p->prior;    
3 free(p);

1 typedef struct
2 {
3 ElemType *base;
4 ElemType *top;
5 int stackSize;
6 }sqStack;

1 #define STACK_INIT_SIZE 100
2 initStack(sqStack *s)
3 {
4 s->base = (ElemType *)malloc( STACK_INIT_SIZE * sizeof(ElemType) );
5 if( !s->base )
6 exit(0);
7 s->top = s->base;   // 最开始，栈顶就是栈底
8 s->stackSize = STACK_INIT_SIZE;
9 }

 1 #define SATCKINCREMENT 10
 2 
 3 Push(sqStack *s, ElemType e)
 4 {
 5     // 如果栈满，追加空间
 6     if( s->top – s->base >= s->stackSize )
 7     {
 8         s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
 9         if( !s->base )
10             exit(0);
11 
12         s->top = s->base + s->stackSize;              // 设置栈顶
13         s->stackSize = s->stackSize + STACKINCREMENT; // 设置栈的最大容量
14     }
15 
16     *(s->top) = e;
17     s->top++;
18 }

1 Pop(sqStack *s, ElemType *e)
2 {
3 if( s->top == s->base )  // 栈已空空是也
4 return;
5 *e = *--(s->top);
6 }

 1 DestroyStack(sqStack *s){
 2 int i, len;
 3 len = s->stackSize;
 4 for( i=0; i < len; i++ ){
 5 free( s->base );
 6 s->base++;
 7 }
 8 s->base = s->top = NULL;
 9 s->stackSize = 0;
10 }

1 int StackLen(sqStack s)
2 {
3 return(s.top – s.base);  // 初学者需要重点讲解
4 }

 1 teypedef struct StackNode
 2 {
 3 ElemType data;    // 存放栈的数据
 4 struct StackNode *next;
 5 } StackNode, *LinkStackPtr;
 6 teypedef struct LinkStack
 7 {
 8 LinkStackPrt top;    // top指针
 9 int count;        // 栈元素计数器
10 }

1 Status Push(LinkStack *s, ElemType e)
2 {
3 LinkStackPtr p = (LinkStackPtr) malloc (sizeof(StackNode));
4 p->data = e;
5 p->next = s->top;
6 s->top = p;
7 s->count++;
8 return OK;
9 }

 1 Status Pop(LinkStack *s, ElemType *e)
 2 {
 3 LinkStackPtr p;
 4 if( StackEmpty(*s) )  // 判断是否为空栈
 5 return ERROR;
 6 *e = s->top->data;
 7 p = s->top;
 8 s->top = s->top->next;
 9 free(p);
10 s->count--;
11 return OK;
12 }

1 initQueue(LinkQueue *q)
2 {
3 q->front=q->rear=(QueuePtr)malloc(sizeof(QNode));
4 if( !q->front )
5         exit(0);
6 q->front->next = NULL;
7 }

 1 InsertQueue(LinkQueue *q, ElemType e)
 2 {
 3 QueuePtr p;
 4 p = (QueuePtr)malloc(sizeof(QNode));
 5 if( p == NULL )
 6 exit(0);
 7 p->data = e;
 8 p->next = NULL;
 9 q->rear->next = p;
10 q->rear = p;
11 }

 1 DeleteQueue(LinkQueue *q, ELemType *e)
 2 {
 3 QueuePtr p;
 4 if( q->front == q->rear )
 5 return;
 6 p = q->front->next;
 7 *e = p->data;
 8 q->front->next = p->next;
 9 if( q->rear == p )
10 q->rear = q->front;
11 free(p);
12 }

1 DestroyQueue(LinkQueue *q)
2 {
3 while( q->front ) {
4 q->rear = q->front->next;
5 free( q->front );
6 q->front = q->rear;
7 }
8 }

1 #define MAXSIZE 100
2 typedef struct
3 {
4 ElemType *base; // 用于存放内存分配基地址
5             // 这里你也可以用数组存放
6 int front;
7 int rear;
8 }

1 initQueue(cycleQueue *q)
2 {
3 q->base = (ElemType *) malloc (MAXSIZE * sizeof(ElemType));
4 if( !q->base )
5 exit(0);
6 q->front = q->rear = 0;
7 }

1 InsertQueue(cycleQueue *q, ElemType e)
2 {
3 if( (q->rear+1)%MAXSIZE == q->front )
4 return; // 队列已满
5 q->base[q->rear] = e;
6 q->rear = (q->rear+1) % MAXSIZE;
7 }

1 DeleteQueue(cycleQueue *q, ElemType *e)
2 {
3 if( q->front == q->rear )
4 return ; // 队列为空
5 *e = q->base[q->front];
6 q->front = (q->front+1) % MAXSIZE;
7 }