王道数据结构与算法代码（与书本伪代码统一）有思维导图逐句注解 持续更新

已于 2022-09-16 21:25:51 修改
阅读量3.4k 收藏 133
点赞数 14
分类专栏： 爱学习:数据结构与算法 文章标签： c语言 c++ 数据结构
于 2022-08-03 23:38:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46263778/article/details/126150684
版权

本文以王道23版本数据结构与算法书本伪代码为基础进行编写
内容仅供参考，配有个人编写代码辅助思维导图，有部分地方为个人理解，如果发现理解有偏差或者有误欢迎评论区指正，谢谢大家。

01.typedef的使用

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct student
{
	int num;
	char name[30];
	char sex[30];
}stu, * Studefine;

typedef int INT;
int main()
{
	stu s = { 1080,"ssao","nan" };
	Studefine p;
    INT n = 100;
	p = &s;
	printf("%d,p->num=%d", n, p->num);
	return 0;
}

02.c++的使用

#include <stdio.h>
#include <malloc.h>

void change(int& s)
{
	s++;

};
void gave(int*& d)
{
	d = (int*)malloc(20);//强制类型转换
	d[0] = 1;
}

int main()
{
	int s = 10;
	change(s);
	printf("%d\n", s);
	int* d = NULL;
	gave(d);
	printf("%d\n", d[0]);
	return 0;


}

03.顺序表的增删查

#include <stdio.h>
#include <stdlib.h>

#define MaxSize 50//这个地方不要加“；”
typedef int Minter;
typedef  struct
{
	Minter data[MaxSize];
	int len;
}Sqlist;

//插入操作
bool Cain(Sqlist& L, int i, Minter e)
{
	if (i < 1 || i > L.len)
		return false;
	if (L.len >= MaxSize)
		return false;
	for (int j = L.len; j >= i; j--)
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;
	L.len++;
	return true;
}
//打印操作
void printf_m(Sqlist& L)
{
	for (int i = 0; i < L.len; i++)
		printf("%3d", L.data[i]);
	printf("\n");
}
//删除操作
bool DelList(Sqlist& L, int i, Minter& e)
{
	if (i < 1 || i > L.len)
		return false;
	if (L.len == 0)
		return false;
	e = L.data[i - 1];
	for (int j = i; j < L.len; j++)
		L.data[j - 1] = L.data[j];
	L.len--;
	return true;


}
//查找操作
int FindList(Sqlist& L, Minter e)
{
	for (int i = 0; i < L.len; i++)
		if (L.data[i] == e)
			return i + 1;
	return 0;
}
int main()
{
	Sqlist L;
	bool res;
	int del = 0;//存储删除元素
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.len = 3;
	//插入部分调用及反馈
	res = Cain(L, 2, 60);
	if (res)
	{
		printf("插入成功\n");
		printf_m(L);
	}
	else
	{
		printf("插入失败\n");
	}
	//删除部分调用及反馈
	res = DelList(L, 1, del);
	if (res)
	{
		printf("删除成功\n");
		printf_m(L);
	}
	else
	{
		printf("删除失败\n");
	}
	int ele_pos;
	ele_pos = FindList(L, 60);
	if (ele_pos)
	{
		printf("查找成功\n元素位置为 %d\n", ele_pos);
	}
	else
	{
		printf("查找失败");

	}
}

04.线性表的链式表示

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
//3 4 5 6 7 9999
typedef int Emoint;
typedef struct Lnote
{
	Emoint data;
	struct Lnote* next;
}Lnote, * Linklist;
//头插法
Linklist Chahead(Linklist& L)
{
	Lnote* s; int x;
	L = (Linklist)malloc(sizeof(Lnote));
	L->next = NULL;
	scanf("%d", &x);
	while (x != 9999)
	{
		s = (Lnote*)malloc(sizeof(Lnote));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}
//尾插法
Linklist Chatail(Linklist& L)
{
	int x;
	L = (Linklist)malloc(sizeof(Lnote));
	Lnote* s, * r = L;
	scanf("%d", &x);
	while (x != 9999)
	{
		s = (Lnote*)malloc(sizeof(Lnote));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return L;
}
//打印
void PrintfList(Linklist L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%3d", L->data);
		L = L->next;
	}
	printf("\n");
}
//按序号查找结点值
Linklist NumFind(Linklist L, int i)
{
	int j = 1;
	Lnote* p = L->next;//让p指向第一个结点
	if (i == 0)
		return L;//i是零就返回头结点
	if (i < 1)
		return NULL;
	while (p && j < i)
	{
		p = p->next;//让p指向下一个结点
		j++;
	}
	return p;
}
//按值查找结点值
Linklist Find(Linklist L, Emoint i)
{
	Linklist p = L->next;
	while (p != NULL && p->data != i)
		p = p->next;
	return p;
}
//新结点处插入操作
bool ChaList(Linklist L, int i, Emoint j)
{
	Linklist p = NumFind(L, i - 1);
	if (p == NULL)
		return false;
	Linklist s = (Linklist)malloc(sizeof(Lnote));
	s->data = j;
	s->next = p->next;
	p->next = s;
	return 0;
}
//删除操作
bool DelList(Linklist L, int  i)
{
	Linklist p = NumFind(L, i - 1);
	if (p == NULL)
		return false;
	Linklist s;
	s = p->next;
	p->next = s->next;
	free(s);
	return true;
}
//主函数
int main()
{
	Linklist L;
	Linklist Cun;
	Chahead(L);//头插法	
	//Chatail(L);//尾插法
	PrintfList(L);//打印
	//按序号查找
	Cun = NumFind(L, 4);
	if (Cun != NULL)
	{
		printf("按序号查找成功\n");
		printf("%d\n", Cun->data);
	}
	//按值查找
	Cun = Find(L, 6);
	if (Cun != NULL)
	{
		printf("按值查找成功\n");
		printf("%d\n", Cun->data);
	}
	//插入节点
	ChaList(L, 2, 99);
	if (true)
	{
		printf("插入成功\n");
		PrintfList(L);
	}
	//删除节点
	DelList(L, 4);
	if (true)
	{
		printf("删除成功\n");
		PrintfList(L);
	}
}

05.双向链表

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

typedef int Elemon;
typedef struct NBone
{
	Elemon data;
	struct NBone* prior, * next;
}NB, * NBlist;
//头插法
NBlist ChaHead(NBlist& DL)
{
	NB* p; int x;
	DL = (NBlist)malloc(sizeof(NB));
	DL->next = NULL;
	DL->prior = NULL;
	scanf("%d", &x);
	while (x != 9999)
	{
		p = (NBlist)malloc(sizeof(NB));
		p->data = x;
		p->next = DL->next;
		if (DL->next != NULL)
		{
			DL->next->prior = p;
		}
		p->prior = DL;
		DL->next = p;
		scanf("%d", &x);
	}
	return DL;

}
//打印操作
void PrintfDL(NBlist DL)
{
	DL = DL->next;
	while (DL->next != NULL)
	{
		printf("%3d", DL->data);
		DL = DL->next;
	}
	printf("\n");
}
//尾插法
NBlist ChaTail(NBlist& DL)
{
	int x;
	DL = (NBlist)malloc(sizeof(NB));
	NBlist s, r = DL;
	scanf("%d", &x);
	while (x != 9999)
	{
		s = (NBlist)malloc(sizeof(NB));
		s->data = x;
		r->next = s;
		s->prior = r;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return DL;
}
//按序号查找
NBlist numFind(NBlist& DL, int i)
{
	int j = 1;
	NBlist p = DL->next;
	if (i == 0)
		return DL;
	if (i < 1)
		return NULL;
	while (p && j < i)
	{
		p = p->next;
		j++;
	}
	return p;

}
//插入
bool ChaAom(NBlist DL, int i, Elemon e)
{
	NBlist p = numFind(DL, i - 1);
	if (p == NULL)
		return false;
	NBlist s = (NBlist)malloc(sizeof(NB));
	s->data = e;
	s->next = p->next;
	p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}
//删除
bool DelDL(NBlist DL, int i)
{
	NBlist p = numFind(DL, i - 1);
	if (p == NULL)
		return false;
	NBlist r;
	r = p->next;
	if (r == NULL)
		return false;
	p->next = r->next;
	if (r->next != NULL)
		r->next->prior = p;
	free(r);
	return true;
}
//主函数
int main()
{
	//3 4 5 6 7 9999
	NBlist DL;
	NBlist search;
	//ChaHead(DL);
	ChaTail(DL);
	PrintfDL(DL);
	search = numFind(DL, 3);
	if (search != NULL)
	{
		printf("查找成功结果如下\n");
		printf("%3d\n", search->data);
	}
	ChaAom(DL, 2, 99);
	if (true)
	{

		printf("插入成功结果如下\n");
		PrintfDL(DL);
	}

	DelDL(DL, 2);
	if (true)
	{

		printf("删除成功结果如下\n");
		PrintfDL(DL);
	}


}

06.栈

#include <stdio.h>
#include <stdlib.h>

#define MaxSize 50
typedef int Zlist;
typedef struct
{
	Zlist data[MaxSize];
	Zlist top;
}NBlist;
//初始化
void Tof(NBlist& S)
{
	S.top = -1;
}
//判断是否初始化成功
bool PanList(NBlist& S)
{
	if (S.top == -1)
	{
		return true;

	}
	return false;
}
//入栈
bool PutIn(NBlist& S, Zlist x)
{
	if (S.top == MaxSize - 1)

	{
		return false;
	}
	/*S.top = S.top + 1;
	S.data[S.top]=x;*/
	S.data[++S.top] = x;//S.top=S.top+1 ;S.data[S.top];
	return true;
}
//获取栈顶元素
bool Take(NBlist& S, Zlist& x)
{
	if (S.top == -1)
	{
		return false;
	}

	x = S.data[S.top];
	return true;
}
//出栈操作
bool OutZhan(NBlist& S, Zlist& x)
{
	if (S.top == -1)
	{
		return false;
	}
	x = S.data[S.top];
	S.top = S.top - 1;
	return true;

}
int main()
{
	NBlist S;
	bool flag;
	Zlist m;
	//栈初始化
	Tof(S);
	//判断栈是否为空
	flag = PanList(S);
	if (flag)
	{
		printf("栈是空的\n");
	}
	//入栈操作
	PutIn(S, 3);
	PutIn(S, 4);
	PutIn(S, 5);
	//获取栈顶元素
	flag = Take(S, m);
	if (flag)
	{
		printf("获取栈顶元素为%d\n", m);
	}
	//出栈操作
	flag = OutZhan(S, m);
	if (flag)
	{
		printf("弹出的元素为%d\n", m);
	}
}

07.循环队列

#include <stdio.h>;
#include <stdlib.h>;

#define MaxSize 5//这个地方一定不要加分号
typedef int EmlyInt;
typedef struct {
	EmlyInt data[MaxSize];
	EmlyInt front, rear;
}NbList;
//初始化
bool NewList(NbList& S)
{
	S.front = S.rear = 0;
	return true;
}
//判断是否为空
bool KanList(NbList& S)
{
	if (S.front == S.rear)
	{
		return true;
	}
}
//入队
bool Inlist(NbList& S, EmlyInt x)
{
	if ((S.rear + 1) % MaxSize == S.front)
		return false;
	S.data[S.rear] = x;
	S.rear = (S.rear + 1) % MaxSize;
	return true;
}
//出队
bool Outlist(NbList& S, EmlyInt& m)
{
	if (S.front == S.rear)
		return false;
	m = S.data[S.front];
	S.front = (S.front + 1) % MaxSize;
}
int main()
{
	NbList S;
	bool res;
	EmlyInt search;
	NewList(S);
	//判断
	res = KanList(S);
	if (res)
	{
		printf("队列为空\n");
	}
	else
	{
		printf("队列不为空");
	}

	//入队
	Inlist(S, 3);
	Inlist(S, 4);
	Inlist(S, 5);
	res = Inlist(S, 6);
	res = Inlist(S, 7);
	if (res)
	{
		printf("入队成功\n");
	}
	else
	{

		printf("入队失败\n");
	}
	//出队
	res = Outlist(S, search);
	if (res)
	{
		printf("出队成功，元素值为%d\n", search);
	}
	else
	{

		printf("出队失败\n");
	}
	res = Outlist(S, search);
	if (res)
	{
		printf("出队成功，元素值为%d\n", search);
	}
	else
	{

		printf("出队失败\n");
	}
}

08.队列的链式存储

#include <stdio.h>
#include <stdlib.h>
typedef int Elmpey;
typedef struct NumList
{
	Elmpey data;
	struct NumList* next;
}NumList;

typedef struct
{
	NumList* front;
	NumList* rear;
}LinkQu;
//初始化操作
void NewList(LinkQu& S)
{
	S.front = S.rear = (NumList*)malloc(sizeof(NumList));
	S.front->next = NULL;
}
//入队操作
void InList(LinkQu& S, Elmpey x)
{
	NumList* p = (NumList*)malloc(sizeof(NumList));
	p->data = x; p->next = NULL;
	S.rear->next = p;
	S.rear = p;
}
//出队操作
bool OutList(LinkQu& S, Elmpey& x)
{
	if (S.front == S.rear)
		return false;
	NumList* s = S.front->next;
	x = s->data;
	S.front->next = s->next;
	if (s == S.rear)
		S.front = S.rear;
	free(s);
	return true;
}
int main()
{
	LinkQu S;
	bool res;
	Elmpey ForIn;
	NewList(S);
	InList(S, 3);
	InList(S, 4);
	InList(S, 5);
	InList(S, 6);
	InList(S, 7);
	res = OutList(S, ForIn);
	if (res)
	{
		printf("出队成功，出队元素为%d", ForIn);
	}
	else
	{
		printf("出队失败了");

	}
}

09.斐波那契数列

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

int Fib(int n)
{
	if (n == 0)
		return 0;
	else if (n == 1)
		return 1;
	else
		return Fib(n - 1) + Fib(n - 2);

}
int main()
{
	int num;
	while (scanf("%d", &num) != EOF)
	{
		printf("Fib(%d)=%d\n", num, Fib(num));

	}
}

10.二叉树的遍历

function.h

#define CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
typedef char BiElemType;
typedef struct BiTNode {
	BiElemType c;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;

typedef struct tag {
	BiTree p;
	struct tag* pnext;
}tag_t, * ptag_t;

//栈的相关数据结构
#define MaxSize 50
typedef BiTree ElemType;
typedef struct {
	ElemType data[MaxSize];
	int top;
}SqStack;
void InitStack(SqStack& S);
bool StackEmpty(SqStack& S);
bool Push(SqStack& S, ElemType x);
bool Pop(SqStack& S, ElemType& x);
bool GetTop(SqStack& S, ElemType& x);
//队列的相关数据结构
typedef struct LinkNode {
	ElemType data;
	struct LinkNode* next;
}LinkNode;
typedef struct {
	LinkNode* front, * rear;
}LinkQueue;
void InitQueue(LinkQueue& Q);
bool IsEmpty(LinkQueue Q);
void EnQueue(LinkQueue& Q, ElemType x);
bool DeQueue(LinkQueue& Q, ElemType& x);

queue.cpp

#include "function.h"
//代头结点的队列
void InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next=NULL;
}

bool IsEmpty(LinkQueue Q)
{
	if(Q.front==Q.rear)
		return true;
	else
		return false;
}

void EnQueue(LinkQueue &Q,ElemType x)
{
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;s->next=NULL;
	Q.rear->next=s;
	Q.rear=s;
}

bool DeQueue(LinkQueue &Q,ElemType &x)
{
	if(Q.front==Q.rear) return false;
	LinkNode *p=Q.front->next;
	x=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)
		Q.rear=Q.front;
	free(p);
	return true;
}

stack.cpp

#include "function.h"


void InitStack(SqStack &S)
{
	S.top=-1;
}

bool StackEmpty(SqStack &S)
{
	if(S.top==-1)
		return true;
	else
		return false;
}
//入栈
bool Push(SqStack &S,ElemType x)
{
	if(S.top==MaxSize-1)
	{
		return false;
	}
	S.data[++S.top]=x;
	return true;
}
//出栈
bool Pop(SqStack &S,ElemType &x)
{
	if(-1==S.top)
		return false;
	x=S.data[S.top--];
	return true;
}
//读取栈顶元素
bool GetTop(SqStack &S,ElemType &x)
{
	if(-1==S.top)
		return false;
	x=S.data[S.top];
	return true;
}

main.cpp


#include "function.h"

//递归实现
//abdhiejcfg
void preOrder(BiTree p)
{
	if(p!=NULL)
	{
		putchar(p->c);//等价于visit函数
		preOrder(p->lchild);
		preOrder(p->rchild);
	}
}
//中序遍历  hdibjeafcg
void InOrder(BiTree p)
{
	if(p!=NULL)
	{
		InOrder(p->lchild);
		putchar(p->c);
		InOrder(p->rchild);
	}
}
//hidjebfgca
void PostOrder(BiTree p)
{
	if(p!=NULL)
	{
		PostOrder(p->lchild);
		PostOrder(p->rchild);
		putchar(p->c);
	}
}
void InOrder2(BiTree T)
{
	SqStack S;
	InitStack(S);BiTree p=T;
	while(p||!StackEmpty(S))//逻辑或||
	{
		if(p)
		{
			Push(S,p);
			p=p->lchild;
		}else{
			Pop(S,p);putchar(p->c);
			p=p->rchild;
		}
	}
}
//层次遍历,广度优先遍历
void LevelOrder(BiTree T)
{
	LinkQueue Q;//定义队列
	InitQueue(Q);//初始化带头结点的队列
	BiTree p;//树指针
	EnQueue(Q,T);//树根入队
	while(!IsEmpty(Q))//判断是否为空
	{
		DeQueue(Q,p);
		putchar(p->c);
		if(p->lchild!=NULL)
			EnQueue(Q,p->lchild);
		if(p->rchild!=NULL)
			EnQueue(Q,p->rchild);
	}
}
#include "function.h"


void InitStack(SqStack& S)
{
	S.top = -1;
}

bool StackEmpty(SqStack& S)
{
	if (S.top == -1)
		return true;
	else
		return false;
}
//入栈
bool Push(SqStack& S, ElemType x)
{
	if (S.top == MaxSize - 1)
	{
		return false;
	}
	S.data[++S.top] = x;
	return true;
}
//出栈
bool Pop(SqStack& S, ElemType& x)
{
	if (-1 == S.top)
		return false;
	x = S.data[S.top--];
	return true;
}
//读取栈顶元素
bool GetTop(SqStack& S, ElemType& x)
{
	if (-1 == S.top)
		return false;
	x = S.data[S.top];
	return true;
}
int main()
{
	BiTree pnew;
	int i,j,pos;
	char c;
	BiTree tree=NULL;//树根
	ptag_t phead=NULL,ptail=NULL,listpnew,pcur;
	//abcdefghij

	while(scanf("%c",&c)!=EOF)
	{
		if(c=='\n')
		{
			break;
		}
		pnew=(BiTree)calloc(1,sizeof(BiTNode));
		pnew->c=c;
		listpnew=(ptag_t)calloc(1,sizeof(tag_t));
		listpnew->p=pnew;
		if(NULL==tree)
		{
			tree=pnew;//树的根
			phead=listpnew;//队列头
			ptail=listpnew;//队列尾
			pcur=listpnew;
			continue;
		}else{
			ptail->pnext=listpnew;//新结点放入链表，通过尾插法
			ptail=listpnew;//ptail指向队列尾部
		}//pcur始终指向要插入的结点的位置
		if(NULL==pcur->p->lchild)//如何把新结点放入树
		{
			pcur->p->lchild=pnew;//把新结点放到要插入结点的左边
		}else if(NULL==pcur->p->rchild)
		{
			pcur->p->rchild=pnew;//把新结点放到要插入结点的右边
			pcur=pcur->pnext;//左右都放了结点后，pcur指向队列的下一个
		}
	}
	printf("--------前序遍历----------\n");
	preOrder(tree);
	printf("\n--------中序遍历------------\n");
	InOrder(tree);
	printf("\n--------后序遍历------------\n");
	PostOrder(tree);
	printf("\n--------中序遍历非递归------\n");
	InOrder2(tree); 
	printf("\n--------层次遍历-----------\n");
	LevelOrder(tree);
	printf("\n");
	system("pause");
}

11.二插排序树的创建

#include <stdio.h>
#include <stdlib.h>

typedef int KeyType;
typedef struct BSTNode
{
	KeyType key;
	struct BSTNode* lchild, * rchild;
}BSTNode, * Bitree;
//辅助函数
int  BST_Insert(Bitree& T, KeyType x)
{
	if (T == NULL)
	{
		T = (Bitree)malloc(sizeof(BSTNode));
		T->key = x;
		T->lchild = T->rchild = NULL;
		return 1;
	}
	else if (T->key == x)
		return 0;
	else if (T->key > x)
	{
		return BST_Insert(T->lchild, x);
	}
	else
	{
		return BST_Insert(T->rchild, x);
	}


}
//创建
void Creat_BST(Bitree& T, KeyType str[], int n)
{
	T = NULL;
	int i = 0;
	while (i < n)
	{
		BST_Insert(T, str[i]);
		i++;
	}

}
//删除操作
void DeleteNode(Bitree& root, KeyType x)
{
	if (root->key == NULL)//树根为空
		return;
	if (root->key > x)
	{
		DeleteNode(root->lchild, x);
	}
	else if (root->key < x)
	{

		DeleteNode(root->rchild, x);
	}
	else
	{
		if (root->lchild == NULL)
		{
			Bitree tempNode = root;
			root = root->rchild;
			free(tempNode);
		}
		else if (root->rchild == NULL)
		{
			Bitree tempNode = root;
			root = root->lchild;
			free(tempNode);
		}
		else
		{
			Bitree tempNode = root->lchild;
			if (tempNode->rchild != NULL)
			{
				tempNode = tempNode->rchild;
			}
			root->key = tempNode->key;
			DeleteNode(root->lchild, tempNode->key);
		}
	}
}
//查找
BSTNode* BST_Search(Bitree T, KeyType k, Bitree& p)
{
	p = NULL;
	while (T != NULL && k != T->key)
	{
		p = T;
		if (k < T->key)
			T = T->lchild;
		else
			T = T->rchild;
	}
	return T;

}
//中序遍历
int InOrder(Bitree& T)
{
	if (T != NULL)
	{
		InOrder(T->lchild);
		printf("%3d", T->key);
		InOrder(T->rchild);

	}
	return 1;
}
//主函数
int main()
{
	//定义
	Bitree T = NULL;
	Bitree parent;
	Bitree search;
	KeyType str[7] = { 54,20,66,40,28,79,58 };
	//创建
	Creat_BST(T, str, 7);
	//中序遍历
	InOrder(T);
	printf("\n");
	//查找
	search = BST_Search(T, 40, parent);
	if (search)
	{
		printf("查找成功，查找到的值=%d\n", search->key);

	}
	else
	{
		printf("查找失败\n");
	}
	//删除
	DeleteNode(T, 66);
	InOrder(T);
	printf("\n");

}

12.顺序查找和折半查找

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef int ElemType;
//定义
typedef struct {
	ElemType* elem;
	int TableLen;

}SStable;
//生成随机数
void ST_lnit(SStable& ST, int x)
{
	ST.TableLen = x + 1;
	ST.elem = (ElemType*)malloc(sizeof(ElemType) * ST.TableLen);
	int i;
	srand(time(NULL));//随机数生成
	for (i = 0; i < ST.TableLen; i++)
	{
		ST.elem[i] = rand() % 100;
	}
}
//打印
void ST_print(SStable& ST)
{
	for (int i = 0; i < ST.TableLen; i++)
	{
		printf("%3d", ST.elem[i]);
	}
	printf("\n");
}
//查找
int Search_Seq(SStable ST, ElemType key)
{
	ST.elem[0] = key;//哨兵
	int i;
	for (i = ST.TableLen - 1; ST.elem[i] != key; --i);
	return i;
}
//比较规则
int compare(const void* left, const void* right)
{
	return *(ElemType*)left - *(ElemType*)right;
}
//二分查找
int Binary_Search(SStable ST, ElemType key)
{
	int low = 0, high = ST.TableLen - 1, mid;
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (ST.elem[mid] == key)
			return mid;
		else if (ST.elem[mid] > key)
			high = mid + 1;
		else
			low = mid + 1;
	}
	return -1;
}
//主函数
int main()
{
	SStable ST;
	ElemType key;
	int pos;
	//生成随机数
	ST_lnit(ST, 10);
	ST_print(ST);
	//查找
	printf("请输入要搜索的key值\n");
	scanf("%d", &key);
	pos = Search_Seq(ST, key);
	if (key)
	{
		printf("查找成功，位置是%d\n", pos);
	}
	else
	{
		printf("查找失败");
	}
	//折半查找
	qsort(ST.elem, ST.TableLen, sizeof(ElemType), compare);
	ST_print(ST);
	printf("二分查找，请输入要搜索的key值\n");
	scanf("%d", &key);
	pos = Binary_Search(ST, key);
	if (pos != -1)
	{
		printf("查找成功，位置是%d\n", pos);
	}
	else
	{
		printf("查找失败\n", pos);
	}
	return 0;
}
出色的你csdw
关注
  • 14
    点赞
  • 踩
  • 133
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
王道数据结构代码笔记
My博客
07-15 3340
数据结构考研代码
2023王道数据结构-单链表基本操作的实现代码（C++版）
qq_45961676的博客
05-10 1217
王道数据结构单链表基本操作
王道考研数据结构代码总结（第五章）
正在考研ing
06-09 1439
本文包含王道考研讲课中所涉及的数据结构中的所有代码，当PPT代码和书上代码有所区别时以咸鱼的PPT为主，个人认为PPT上的代码比王道书上的代码要便于理解，此外，本博客也许会补充一些额外的代码进来（不仅受限于王道考研），408中冷门考点频出，应该会囊括所有涉及到的代码，这也是我的DS的第二轮复习，希望与大家共勉之。DS的后四章只有最后一章（排序）涉及大量的代码，而树，图，查找这三章，对于概念的考察比较深入，故本文对于前三章也会进行概念上的整理，代码的话也同样会全部给出。
24王道考研408数据结构代码整合（学习用）
Ch_ensf的博客
10-27 3210
define MaxSize 10 //定义最大长度//用静态的“数组”存放数据元素int length;//顺序表的当前长度}SeqList;//顺序表的类型定义（静态分配方式）//基本操作——初始化一个顺序表i
《数据结构》（学习笔记）（王道）
最新发布
qiqi_liuliu的博客
04-23 997
Personal study notes, please point out any errors, thank you!
王道考研数据结构--1.顺序表
我是个好人呀，????
06-20 655
日期：2023.6.20书籍：2024年数据结构考研复习指导（王道考研系列）内容：静态存储实现顺序表，及其基本操作，初始化，增加，删除，查找，判空和遍历输出。
王道数据结构【二叉树】部分代码实现（C语言）
年少的勇气已经用完，剩下的就是三思而后行
07-28 1728
王道数据结构【二叉树】部分代码实现（C语言）
【超详细】数据结构与操作系统思维导图（王道考研）.rar
08-03
考研时自己根据王道知识点进行总结的数据结构和操作系统的思维导图，内容全面详细。不管考研还是平时课程用于知识点梳理和总结都不错，需要使用XMind软件打开，没有转成pdf档，考虑后续可根据自己学习进行补充。(加...
王道数据结构思维导图无水印版
04-02
王道数据结构思维导图无水印版
最值得收藏的 数据结构 全部知识点思维导图整理(王道考研), 附带经典题型整理.emmx
03-27
用mindmaster打开文件, 本文的思维导图根据王道的数据结构书本整理而来并标记出重点内容，包括了知识点和部分课后习题
王道数据结构思维导图总结
09-24
数据结构是计算机科学中的核心概念，它涉及到如何在内存..."王道数据结构"的思维导图总结提供了一个全面的框架，帮助学习者系统地回顾和巩固所学知识。在学习过程中，配合实际编程练习，能够更好地理解和运用这些概念。
王道考研数据结构顺序表代码
05-15
自己写的王道考研数据结构顺序表例题和习题代码，所有函数运行都没问题。
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
数据结构王道教材2018年版本
01-04
数据结构王道教材2018年版本数据结构王道教材2018年版本
数据结构思维导图.pdf
10-09
总的来说，数据结构思维导图涵盖了数据结构的基本概念、算法的评价标准、各种数据结构的特性和操作，以及它们在实际问题中的应用。理解并熟练掌握这些知识，对于解决复杂的编程问题和设计高效的计算机程序至关重要。...
C数据结构-单链表-王道数据结构学习总结
lalaladamowang的博客
08-17 549
C数据结构-单链表-王道学习总结前言指针单链表创建一个单链表单链表头部插入元素单链表尾部插入元素单链表遍历 前言 最近要把学校里学的基础理论重新捡起来了，然后因为之前上数据结构的时候是用python上的，但是考试需要用C，所以这次用C来学习，因为之前没怎么学过C，不过本着语言一通都通的美好想法，我直接上手。顺序表还是一路通关的，单链表这里卡了一会儿，王道上的代码都是伪代码，实际用C语言跑还是会碰到一些问题。特别是C的指针需要深刻理解，对于后面的学习会有帮助。 指针 #include <stdio.h&
王道数据结构与算法：完整笔记
修行的凡人的博客
04-03 2928
基于著名书籍和自我学习得出的王道数据结构理论知识笔记
【王道考研】王道数据结构与算法详细笔记（全）
热门推荐
强哥的微博
06-08 1万+
线性表是具有相同数据类型的n(n>0)个数据元素的有限序列。(其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为)1. 存在惟一的第一个元素。2. 存在惟一的最后一个元素。3. 除第一个元素之外，每个元素均只有一个直接前驱。4. 除最后一个元素之外，每个元素均只有一个直接后继1.是线性表中的“第i个”元素线性表中的位序。2.是表头元素;是表尾元素。
最小生成树
山鬼谣弋痕夕的博客
05-11 3392
https://blog.csdn.net/luoshixian099/article/details/51908175     关于图的几个概念定义： 连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。 强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。 连通网：在连通图中，若图的边具有一定的意义，每一条边都...
数据结构思维导图 可搜索版
07-16
数据结构思维导图涵盖了数据的概念、类型、逻辑与存储结构、运算等多个方面，这对于理解和设计高效的数据处理算法至关重要。掌握数据结构有助于程序员优化程序性能，提高代码的清晰性和可维护性。王道U2学员在学习...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

出色的你csdw

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值