数据结构面试题

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;
}