考研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;//孩子链表