考研408数据结构代码

快速排序

void quick_sort(int q[], int l, int r)
{
	if (l >= r) return;//左大于右边 return
	int  i = l - 1, j = r + 1, x = q[l + r >> 1];//	 定边界
	while (i < j)
	{
		do i++;
		while (q[i] < x); //小于x的数放在x左边
		do j--;
		while (q[j] > x);// 大于x的数放在x右边
	}
	quick_sort(q, l, j), quick_sort(q, j + 1, r); //递归操作 分别对左右两边的数组排序
}

折半排序

int search(int key[], int n, int  k)
{
	int low = 0, high = n - 1, mid;
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (key[mid] == k)
			return mid;	//查找成功，返回mid 
		if (k > key[mid])
			low = mid + 1;	//在后半序列中查找 
		else
			high = mid - 1;	//在前半序列中查找 
	}
	return -1;//查找失败，返回-1 
}

归并排序

void merge(int q[], int l, int r)
{
	if (l >= r) return;
	int mid = l + r >> 1;
	merge(q, l, mid), merge(q, mid, r);//递归操作 分别对左右两边的数组排序

	int  k = 0, i = l, j = mid + 1, tmp[10010];
	while (i <= mid && j <= r)//边界
	{
		//分别比较两个数组个个元素大小 小的依次放在tmp数组里
		if (q[i] <= q[j]) tmp[k++] = q[i++]; 
		else tmp[k++] = q[j++];
	}
	while (i <= mid) tmp[k++] = q[i++];
	while (j <= r) tmp[k++] = q[j++];

	for (i = l, j = 0; i <= r; i++, j++) q[i] = tmp[j];
}

单链表 ，双链表//考的概率不大（应该）

const int  N = 100010;
int head, e[N], ne[N], idx; // head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
// 初始化
void init()
{
	head = -1;
	idx = 0;
}
// 在链表头插入一个数a
void insert(int a)
{
	e[idx] = a, ne[idx] = head, head = idx++;
}
// 将头结点删除，需要保证头结点存在
void remove() 
{
	head = ne[head];
}

// 双链表
int e[N], l[N], r[N], idx;// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
// 初始化
void double_init()
{
	r[0] = 1, l[1] = 0;
	idx = 2;
}
// 在节点a的右边插入一个数x
void double_insert(int a, int x)
{
	e[idx] = x;
	l[idx] = a, r[idx] = r[a];//当前结点的左指针值为a，右指针值为x
	l[r[a]] = idx, r[a] = idx++;
}
// 删除节点a
void remove(int a)
{
	l[r[a]] = l[a];
	r[l[a]] = r[a];
}

栈

// tt表示栈顶
int stk[N], tt = 0, x;

// 向栈顶插入一个数
stk[++tt] = x;

// 从栈顶弹出一个数
tt--;

// 栈顶的值
stk[tt];

// 判断栈是否为空
if (tt > 0)
{

}

队列

// tt表示栈顶
int stk[N], tt = 0, x;

// 向栈顶插入一个数
stk[++tt] = x;

// 从栈顶弹出一个数
tt--;

// 栈顶的值
stk[tt];

// 判断栈是否为空
if (tt > 0)
{

}

///循环队列


// hh 表示队头，tt表示队尾的后一个位置
int q[N], hh = 0, tt = 0;

// 向队尾插入一个数
q[tt ++ ] = x;
if (tt == N) tt = 0;

// 从队头弹出一个数
hh ++ ;
if (hh == N) hh = 0;

// 队头的值
q[hh];

// 判断队列是否为空
if (hh != tt)
{

}

顺序栈

// 顺序栈
#define N 90
typedef struct  Sqstrack {
	int data[N];
	int top;
} Sqstrack;

// 初始化
void InitStack(Sqstrack& S) {
	S.top = -1;  
}
// 栈空
bool StackEmpty(Sqstrack S) {
	if (S.top = -1)//栈空条件
		return true;
	else
		return false;
}
// 进栈
bool push(Sqstrack& S, int x)
{
	if (S.top == N - 1);
	return false;
	S.data(++S.top) = x;
	return ture;
}
//出栈
bool push(Sqstrack& S, int x)
{
	if (S.top == - 1);
	return false;
	x = S.data(S.top--);
	return ture;
}

链栈 // 真的会考这个吗？

//1.定义数据类型
typedef int ElemType;
//2.定义链栈结构体
typedef struct LinkStackNode
{
	ElemType data;//存数据
	struct LinkStackNode* next;//存下个节点的地址
} LinkStack;
//3.初始化链栈
int initLinkStack(LinkStack* L)
{
	L = (LinkStack*)malloc(sizeof(LinkStack));//申请内存
	if (!L->data) return 0;//申请失败
	L->data = 0;//初始化链栈头结点数据域
	L->next = NULL;//初始化链栈头结点指针域
	return 1;
}
//4.入栈
int push(LinkStack* L, ElemType e)
{
	LinkStack* n;//新节点
	n = (LinkStack*)malloc(sizeof(LinkStack));
	if (!n->data) return 0;
	n->data = e;//存入数据
	n->next = L->next;//链栈栈顶元素链入新节点，新节点变成栈顶
	L->next = n;//新节点链入链栈头结点末尾
	return 1;
}
//5.出栈
int pop(LinkStack* L, ElemType* e)
{
	if (!L->next) return 0;//栈空，返回0
	LinkStack* d = L->next;//出栈指针指向栈顶
	*e = d->data;//赋值
	L->next = d->next;//头结点跳过出栈节点，链入出栈节点的下一节点
	free(d);//释放内存
	return 1;
}
//6.取栈顶
int getTop(LinkStack* L, ElemType* e)
{
	if (!L->next) return 0;
	*e = L->next->data;
	return 1;
}

树的双亲表示法

typedef struct PTNode {
	int data;
	int parent;//双亲位置域
}PTNode;

typedef struct {
	PTNode nodes[N];
	int  n;//结点个数
}PTree;

树的孩子表示法

typedef struct CTNode {//孩子结点
	int child;
	struct CTNode* next;
}*ChildPtr;

typedef struct		//表头结构
{
	int data;
	ChildPtr firstchild;
}CTBox;//孩子链表

#define MAX_TREE_SIZE 100
typedef struct		//树结构
{
	CTBox nodes[MAX_TREE_SIZE];//结点数组
	int n,r;//结点数和根结点的位置
}CTree;

树的孩子兄弟表示法

typedef struct	CSNode	//表头结构
{
	int data;
	struct CSNode *firstChild , *nextsibling;// 第一个孩子和有兄弟指针
}CSNode, *CSTree;//孩子链表