1.单链表的排序
1)冒泡排序:
typedef struct Node{
int val;
node *next;
Node(){ val = 0; next = NULL; }
}node;
void swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
int Length(node *head){
int size = 0;
while (head)
{
size++;
head = head->next;
}
return size;
}
node *sort(node *head){//冒泡排序,只交换数据,不交换结点,增序
int n = Length(head);
node *p = head;
for (int i = 1; i < n; ++i)
{
p = head;
for (int j = 0; j < n - i; ++j)
{
if (p->val>p->next->val) swap(p->val, p->next->val);
p = p->next;
}
}
return head;
}
2)快速排序:
思路:两个指针p和q,都往next方向移动,移动过程中保证p之前的值小于key,p和q之间的值大于key,当q走到尾端时便完成一次划分。
node *Partition(node *pBegin, node *pEnd)
{
if (pBegin == pEnd) return pBegin;
int key = pBegin->val;
node *p = pBegin;
node *q = p->next;
while (q != pEnd)
{
if (q->val < key)
{
p = p->next;
swap(p->val, q->val);
}
q = q->next;
}
swap(p->val, pBegin->val);
return p;
}
node *QuickSort(node *pBegin, node *pEnd)
{
if (pBegin == pEnd) return pBegin;
node *partition = Partition(pBegin, pEnd);
QuickSort(pBegin, partition);
QuickSort(partition, pEnd);
}
注意:快排不适合单链表,原因是即使最理想的情况也要将所有数据交换一遍。
注意:调用格式如下:
QuickSort(head,NULL); //NULL表示尾结点
2.静态链表
静态链表就是用数组实现链表,数组中的每个元素都是一个结构体,包含data和游标cur,其中cur类似链表中的next,指向下一个元素在数组中的下标。
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 1000
typedef int ElemType;
struct StaticLinkList
{
ElemType data;
int cur;
};
typedef enum
{
ERROR = -1,
OK = 1,
}Status;
/*将下标为k的空闲结点回收到备用链表*/
void Free_SSL(StaticLinkList space[], int k)
{
space[k].cur = space[0].cur;
space[0].cur = k;
}
/*返回L中数据元素个数*/
int ListLength(StaticLinkList L[])
{
int j = 0;
int i = L[MAXSIZE - 1].cur;
while (i)
{
i = L[i].cur;
j++;
}
return j;
}
/*将一维数组space中各分量链成一个备用链表*/
Status InitList(StaticLinkList space[])
{
int i;
for (i = 0; i<MAXSIZE - 1; i++)
{
space[i].cur = i + 1;
}
space[MAXSIZE - 1].cur = 0;
return OK;
}
/*若备用链表非空,则返回分配的结点下标,否则返回0*/
int Malloc_SLL(StaticLinkList space[])
{
int i = space[0].cur;
if (space[0].cur)
{
space[0].cur = space[i].cur;
}
return i;
}
/*在L中第i个元素前插入新的数据元素e*/
Status ListInsert(StaticLinkList L[], int i, ElemType e)
{
int j, k, l;
k = MAXSIZE - 1;
if ((i<1) || (i>ListLength(L) + 1))
{
return ERROR;
}
j = Malloc_SLL(L);
if (j)
{
L[j].data = e;
for (l = 1; l <= i - 1; l++)
{
k = L[k].cur;
}
L[j].cur = L[k].cur;
L[k].cur = j;
return OK;
}
return ERROR;
}
/*删除L中第i个数据元素*/
Status ListDelete(StaticLinkList L[], int i)
{
int j, k;
if ((i<1) || (i>ListLength(L)))
{
return ERROR;
}
k = MAXSIZE - 1;
for (j = 1; j <= i - 1; j++)
{
k = L[k].cur;
}
j = L[k].cur;
L[k].cur = L[j].cur;
Free_SSL(L, j);
return OK;
}
/*打印L中各元素*/
void ListDisp(StaticLinkList L[])
{
int i = L[MAXSIZE - 1].cur;
while (i != 0)
{
printf("%d ", L[i].data);
i = L[i].cur;
}
printf("\n");
}
int main(void)
{
StaticLinkList test[MAXSIZE]; //注意:test[0]是空闲链表头结点,test[MAXSIZE]是静态链表的头结点
InitList(test);
printf("after InitList,StaticLinkList test is:");
ListDisp(test);
int i;
for (i = 0; i<10; i++)
{
ListInsert(test, i, i * 10);
printf("after ListInsert,StaticLinkList test is:");
ListDisp(test);
}
for (i = 0; i<10; i++)
{
ListDelete(test, 1);
printf("after ListDelete,StaticLinkList test is:");
ListDisp(test);
}
return EXIT_SUCCESS;
}