数据结构全实现

最新推荐文章于 2022-12-01 17:16:50 发布
最新推荐文章于 2022-12-01 17:16:50 发布
阅读量743 收藏 3
点赞数
文章标签： 数据结构 链表 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alex_Miller/article/details/122927642
版权

目录

文章目录

一.线性表

#define MaxSize 10001
typedef int ElementType;
typedef int Position;
#include<iostream>
using namespace std;

typedef struct LNode* List;
struct LNode
{
	ElementType Data[MaxSize];
	int Last;
};
//struct LNode L;		//访问下标为i的元素 Ptrl->Data[i]
//List Ptrl;


//初始化
List List_MakeEmpty()
{
	List Ptrl;
	Ptrl = (List)malloc(sizeof(struct LNode));
	Ptrl->Last = -1;
	return Ptrl;
}

//查找
int List_Find(ElementType x, List Ptrl)
{
	int i = 0;
	while (i <= Ptrl->Last && Ptrl->Data[i] != x)
	{
		i++;
	}
	if (i > Ptrl->Last)
	{
		cout << "没找到" << endl;
		return -1;
	}
	else {
		cout << "在" << i << "找到了" << endl;
		return i;
	}
}

//插入
bool List_Insert(ElementType x, Position P, List Ptrl)//P存储下标位置
{
	Position i;
	if (Ptrl->Last == MaxSize - 1)
	{
		cout << "表满" << endl;
		return false;
	}
	if (P < 0 || P > Ptrl->Last + 1) { /* 检查插入位置的合法性 */
		cout << "位置不合法" << endl;
		return false;
	}
	for (i = Ptrl->Last; i >= P; i--)
		Ptrl->Data[i + 1] = Ptrl->Data[i]; /* 将位置P及以后的元素顺序向后移动 */
	Ptrl->Data[P] = x;  /* 新元素插入 */
	Ptrl->Last++;       /* Last仍指向最后元素 */
	return true;
}

//删除
bool List_Delete(List Ptrl, Position P)
{ /* 从L中删除指定位置P的元素 */
	Position i;

	if (P < 0 || P > Ptrl->Last) { /* 检查空表及删除位置的合法性 */
		cout << "位置" << P << "不存在元素" << endl;
		return false;
	}
	for (i = P + 1; i <= Ptrl->Last; i++)
		Ptrl->Data[i - 1] = Ptrl->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */
	Ptrl->Last--; /* Last仍指向最后元素 */
	return true;
}

二.链表

#include<iostream>
using namespace std;
typedef int ElementType;

typedef struct Link_List_Node {
	ElementType data; // 值 
	struct Link_List_Node* Next; // 指向下一个结点 
};

//初始化
Link_List_Node *Link_List_MakeEmpty()
{
	Link_List_Node* head = (Link_List_Node*)malloc(sizeof(Link_List_Node));	//声明头指针
	head ->data= NULL;
	head->Next = NULL;
	Link_List_Node* First = (Link_List_Node*)malloc(sizeof(Link_List_Node));
	First->data = 1;
	First->Next = head->Next;
	head->Next = First;
	//cout << head->data << " " << head->Next->data << endl;
	return head;
}

//按值查找
Link_List_Node* Link_List_Find(ElementType x, Link_List_Node* head)
{
	Link_List_Node* ptr = head;
	bool flag = false;
	while (ptr->Next)
	{
		if (ptr->Next->data == x)
		{
			flag = true;
			cout << "找到了" << endl;
			return ptr->Next;
		}
		else
		{
			ptr = ptr->Next;
		}
	}
	if(flag == false)
	{
		cout << "没找到" << endl;
	}
	return head;
}

//按序号查找
Link_List_Node* Link_List_FindKth(int i, Link_List_Node* head)
{
	Link_List_Node *ptr = head;
	int j = 0;
	bool flag = false;
	while (ptr)
	{
		if (j == i)
		{
			flag = true;
			cout << "找到了" << endl;
			return ptr;
		}
		else
		{
			j++;
			ptr = ptr->Next;
		}
	}
	if (!flag)
	{
		cout << "没找到" << endl;
		return head;
	}
}

//插入
Link_List_Node* Link_List_Insert(Link_List_Node* head, int i, ElementType x)
{
	Link_List_Node *ptr = head;
	ptr = Link_List_FindKth(i-1, head);
	Link_List_Node* NewPtr = (Link_List_Node*)malloc(sizeof(Link_List_Node));
	NewPtr->data = x;
	NewPtr->Next = ptr->Next;
	ptr->Next = NewPtr;
	return NewPtr;
}

//删除
Link_List_Node* Link_List_Delete(Link_List_Node* head, int i)
{
	Link_List_Node* ptr = head;
	ptr = Link_List_FindKth(i - 1, head);
	Link_List_Node* p = ptr->Next; // p是要删除的结点
	ptr->Next = ptr->Next->Next;
	free(p);
	return head;
}

三.堆栈

#include<iostream>
using namespace std;
#define Stack_MaxSize 10001
typedef int ElementType;

typedef struct SNode* Stack;
struct SNode
{
	ElementType Data[Stack_MaxSize];
	int Top;
};

//初始化
Stack Create_Stack()
{
	Stack SNode_1 = (Stack)malloc(sizeof(SNode));
	SNode_1->Top = -1;
	return SNode_1;
}

//判断栈满
bool Stack_IsFull(Stack ptr)
{
	if (ptr->Top == Stack_MaxSize - 1)
	{
		cout << "栈满" << endl;
		return true;
	}
	else
	{
		cout << "栈未满" << endl;
		return false;
	}
}

//入栈
void Stack_Push(Stack ptr, ElementType item)
{
	if (Stack_IsFull(ptr))
	{
		return;
	}
	else
	{
		ptr->Data[++(ptr->Top)] = item;
		return;
	}
}

//判断栈空
bool Stack_IsEmpty(Stack ptr)
{
	if (ptr->Top == -1)
	{
		cout << "栈空" << endl;
		return true;
	}
	else
	{
		cout << "栈不空" << endl;
		return false;
	}
}

//出栈
ElementType Stack_Pop(Stack ptr)
{
	if (Stack_IsEmpty(ptr))
	{
		return 0;
	}
	else {
		return(ptr->Data[ptr->Top--]);
	}
}

四.链栈

typedef int ElementType;
#include<iostream>
using namespace std;

typedef struct Link_SNode* Link_Stack;
struct Link_SNode
{
	ElementType Data;
	Link_Stack Next;
};

//创建空链表
Link_Stack Link_Stack_CreateStack()
{
	Link_Stack S;
	S = (Link_Stack)malloc(sizeof(Link_SNode));
	S->Next = NULL;
	return S;
}

//判空
bool Link_Stack_IsEmpty(Link_Stack S)
{
	if (S->Next == NULL)
	{
		cout << "链栈空" << endl;
		return true;
	}
	else
	{
		cout << "链栈不空" << endl;
		return false;
	}
}

//入栈
void Link_Stack_Push(ElementType item, Link_Stack S)
{
	Link_Stack TmpCell;
	TmpCell = (Link_Stack)malloc(sizeof(Link_SNode));
	TmpCell->Data = item;
	TmpCell->Next = S->Next;
	S->Next = TmpCell;
}

//出栈
ElementType Link_Stack_Pop(Link_Stack S)
{
	Link_Stack First_Cell;
	ElementType TopElem;
	if (Link_Stack_IsEmpty(S))
	{
		return 0;
	}
	else {
		First_Cell = S->Next;
		S->Next = First_Cell->Next;
		TopElem = First_Cell->Data;
		free(First_Cell);
		return TopElem;
	}
}

五.队列

#define Queue_MaxSize 10001
#include<iostream>
typedef int ElementType;
using namespace std;

struct QNode
{
	ElementType Data[Queue_MaxSize];
	int rear;
	int front;
};
typedef struct QNode* Queue;

//初始化
Queue Creat_Queue()
{
	Queue Q_1 = (Queue)malloc(sizeof(QNode));
	Q_1->front = -1;
	Q_1->rear = -1;
	//cout << "创建完毕" << endl;
	return Q_1;
}

//判断队满
bool Queue_IsFull(Queue Q)
{
	if ((Q->rear+1)%Queue_MaxSize == Q->front)
	{
		cout << "队满" << endl;
		return true;
	}
	else {
		cout << "队未满" << endl;
		return false;
	}
}

//判断队空
bool Queue_IsEmpty(Queue Q)
{
	if (Q->front == Q->rear)
	{
		cout << "队空" << endl;
		return true;
	}
	else
	{
		cout << "队不空" << endl;
		return false;
	}
}

//入队
void Queue_AddQ(Queue Ptrle, ElementType item)
{
	if (!Queue_IsFull(Ptrle))
	{
		Ptrle->rear = (Ptrle->rear + 1) % Queue_MaxSize;
		Ptrle->Data[Ptrle->rear] = item;
	}
}

//出队
ElementType Queue_Delete(Queue Q)
{
	if (!Queue_IsEmpty(Q))
	{
		Q->front = (Q->front + 1) % Queue_MaxSize;
		return Q->Data[Q->front];
	}
	else
	{
		return 0;
	}
}

六.链队列

#include<iostream>
typedef int ElementType;
using namespace std;

struct Node
{
	ElementType Data;
	struct Node* Next;
};
struct Link_QNode 
{
	struct Node* rear;
	struct Node* front;
};
typedef struct Node* Link_Node;
typedef struct Link_QNode* Link_Queue;

//初始化
Link_Queue Link_Queue_MakeEmpty()
{
	Link_Queue Link_Q = (Link_Queue)malloc(sizeof(Link_QNode));
	//Link_Q->front = (Link_Node)malloc(sizeof(Node));
	//Link_Q->rear = (Link_Node)malloc(sizeof(Node));
	Link_Node Link_Q_Head = (Link_Node)malloc(sizeof(Node));
	Link_Q->front = Link_Q_Head;
	Link_Q->rear = Link_Q_Head;
	Link_Q_Head->Next = NULL;
	cout << "创建成功" << endl;
	return Link_Q;
}

//判断队空
bool Link_Queue_IsEmpty(Link_Queue Link_Q)
{
	if (Link_Q ->front->Next == NULL)
	{
		cout << "链队列空" << endl;
		return true;
	}
	else
	{
		cout << "链队列不空" << endl;
		return false;
	}
}

//入队
void Link_Queue_Add(Link_Queue Link_Q, ElementType x)
{
	Link_Node Link_Q_1 = (Link_Node)malloc(sizeof(Node));
	Link_Q_1->Data = x;
	Link_Q_1->Next = NULL;
	Link_Q->rear->Next = Link_Q_1;
	Link_Q->rear = Link_Q_1;
}

//出队
ElementType Link_Queue_Delete(Link_Queue Link_Q)
{
	Link_Node FrontCell;
	ElementType FrontElem;
	if (!Link_Queue_IsEmpty(Link_Q))
	{
		FrontCell = Link_Q->front->Next;
		FrontElem = FrontCell->Data;
		Link_Q->front->Next = FrontCell->Next;
		if (FrontCell == Link_Q ->rear)
		{
			Link_Q->rear = Link_Q->front;
		}
		free(FrontCell);
		cout << FrontElem << endl;
		return FrontElem;
	}
	return 0;
}

七.树

#include<iostream>
#include"Stack.h"
#include"Queue.h"


typedef int ElementType;
using namespace std;

typedef struct TreeNode* BinTree;
typedef BinTree Position;

struct TreeNode
{
	ElementType Data;
	BinTree Left;
	BinTree Right;
};

//初始化
BinTree BinTree_MakeEmpty(ElementType x)
{
	BinTree BT = (BinTree)malloc(sizeof(TreeNode));
	BT->Data = x;
	BT->Left = NULL;
	BT->Right = NULL;
	cout << "创建成功" << BT->Data << endl;
	return BT;
}

//先序遍历
void Pre_Order_Traversal(BinTree BT)
{
	if (BT)
	{
		cout << BT->Data << endl;
		Pre_Order_Traversal(BT->Left);
		Pre_Order_Traversal(BT->Right);
	}
}

//中序遍历
void In_Order_Traversal(BinTree BT)
{
	if (BT)
	{
		In_Order_Traversal(BT->Left);
		cout << BT->Data << endl;
		In_Order_Traversal(BT->Right);
	}
}

//后序遍历
void Post_Order_Traversal(BinTree BT)
{
	if (BT)
	{
		Post_Order_Traversal(BT->Left);
		Post_Order_Traversal(BT->Right);
		cout << BT->Data << endl;
	}
}

//非递归实现

void In_Oeder_Traversal_Stack(BinTree BT)
{
	BinTree T = BT;
	Stack S = Create_Stack();
	while (T || Stack_IsEmpty(S))
	{
		while (T)
		{
			Stack_Push(S, T->Data);
			T = T->Left;
		}
		if (!Stack_IsEmpty(S))
		{
			T->Data = Stack_Pop(S);
			cout << T->Data << endl;
			T = T->Right;
		}
	}
}

//层次遍历
void Level_Order_Traversal(BinTree BT)
{
	Queue Q; BinTree T;
	if (!BT)
	{
		return;
	}
	Q = Creat_Queue();
	Queue_AddQ(Q, BT->Data);
	
	while (!Queue_IsEmpty(Q))
	{
		T->Data = Queue_Delete(Q);
		cout << T->Data << endl;
		if (T->Left)
		{
			Queue_AddQ(Q, T->Left->Data);
		}
		if (T->Right)
		{
			Queue_AddQ(Q, T->Right->Data);
		}
	}
}


//二叉搜索树
Position Bst_Find(ElementType x, BinTree BST)
{
	if (!BST)
	{
		return NULL;
	}
	if (x > BST->Data)
	{
		return Bst_Find(x, BST->Right);
	}
	else if (x < BST->Data)
	{
		return Bst_Find(x, BST->Left);
	}
	else
	{
		return BST;
	}
}

//找最小值
Position Bst_FindMin(BinTree BST)
{
	if (!BST)
	{
		return NULL;
	}
	else if (!BST->Left)
	{
		return BST;
	}
	else {
		return Bst_FindMin(BST->Left);
	}
}

//找最大值
Position Bst_FindMax(BinTree BST)
{
	if (!BST)
	{
		return NULL;
	}
	else if (!BST->Right)
	{
		return BST;
	}
	else
	{
		return Bst_FindMax(BST->Right);
	}
}

//插入
BinTree Bst_Insert(ElementType x, BinTree BST)
{
	if (!BST)
	{
		BST = (BinTree)malloc(sizeof(TreeNode));
		BST->Data = x;
		BST->Left = NULL;
		BST->Right = NULL;
	}
	else
	{
		if (x < BST->Data)
		{
			BST->Left = Bst_Insert(x, BST->Left);
		}
		else if (x > BST->Data)
		{
			BST->Right = Bst_Insert(x, BST->Right);
		}
	}
	return BST;
}

//删除
BinTree Bst_Delete(ElementType x, BinTree BST)
{
	Position Tmp;
	if (!BST)
	{
		cout << "删除的元素未找到" << endl;
	}
	else if (x < BST->Data)
	{
		BST->Left = Bst_Delete(x, BST->Left);
	}
	else if (x > BST->Data)
	{
		BST->Right = Bst_Delete(x, BST->Right);
	}
	else
	{
		if (BST->Left && BST->Right)		//左右子树都不为空
		{
			Tmp = Bst_FindMin(BST->Right);
			BST->Data = Tmp->Data;
			BST->Right = Bst_Delete(BST->Data, BST->Right);
		}
		else
		{
			Tmp = BST;
			if (!BST->Left)
			{
				BST = BST->Right;
			}
			else if (!BST->Right)
			{
				BST = BST->Left;
			}
			free(Tmp);
		}
	}
	return BST;
}

八.哈夫曼树

#include<iostream>
#include"Heap.h"
using namespace std;

typedef struct HuffmanTreeNode* HuffmanTree;
struct HuffmanTreeNode
{
	int weight;
	HuffmanTree Left, Right;
};

HuffmanTree Huffman(MinHeap H)
{
	int i; HuffmanTree T;
	Build_MinHeap(H);
	for ( i = 1; i < H->size; i++)
	{
		T = (HuffmanTree)malloc(sizeof(HuffmanTreeNode));
		T->Left->weight = Heap_Delete(H);
		T->Right->weight = Heap_Delete(H);
		T->weight = T->Left->weight + T->Right->weight;
		Heap_insert(H, T->weight);
	}
	T->weight = Heap_Delete(H);
	return T;
}

九.堆

#include<iostream>
using namespace std;
#define MaxData 10001
typedef int ElementType;
typedef struct HeapStruct* MaxHeap;
typedef struct HeapStruct* MinHeap;
struct HeapStruct
{
	ElementType* Elements;
	int size;
	int Capacity;
};

//创建最大堆
MaxHeap MaxHeap_Create(int Heap_MaxSize)
{
	MaxHeap H = (MaxHeap)malloc(sizeof(struct HeapStruct));
	H->Elements = (ElementType*)malloc((Heap_MaxSize + 1) * sizeof(ElementType));
	H->size = 0;
	H->Capacity = Heap_MaxSize;
	H->Elements[0] = MaxData;
	cout << "创建成功" << endl;
	return H;
}

//创建最小堆
MinHeap MinHeap_Create(int Heap_MaxSize)
{
	MaxHeap H = (MaxHeap)malloc(sizeof(struct HeapStruct));
	H->Elements = (ElementType*)malloc((Heap_MaxSize + 1) * sizeof(ElementType));
	H->size = 0;
	H->Capacity = Heap_MaxSize;
	H->Elements[0] = MaxData;
	cout << "创建成功" << endl;
	return H;
}


//堆是不是满
bool Heap_IsFull(struct HeapStruct* H)
{
	if (H->size == H->Capacity)
	{
		cout << "堆满" << endl;
		return true;
	}
	else
	{
		cout << "堆未满" << endl;
		return false;
	}
}

//堆是不是空
bool Heap_IsEmpty(struct HeapStruct* H)
{
	if (H->size == 0)
	{
		cout << "堆空" << endl;
		return true;
	}
	else
	{
		cout << "堆不空" << endl;
		return false;
	}
}

//插入
void Heap_insert(struct HeapStruct* H, ElementType item)
{
	int i;
	if (Heap_IsFull(H))
	{
		return;
	}
	i = ++H->size;	//i指向插入后堆中最后一个元素的位置
	for(;H->Elements[i/2] < item; i/=2)
	{
		H->Elements[i] = H->Elements[i / 2];
	}
	H->Elements[i] = item;
}

//删除
ElementType Heap_Delete(struct HeapStruct* H)
{
	int Parent, Child;
	ElementType MaxItem, Temp;
	if (Heap_IsEmpty(H))
	{
		return 0;
	}
	MaxItem = H->Elements[1];
	Temp = H->Elements[H->size--];
	for (Parent = 1; Parent * 2 <= H->size; Parent = Child)
	{
		Child = Parent * 2;
		if ((Child!=H->size)&&(H->Elements[Child] < H->Elements[Child+1]))
		{
			Child++;
		}
		if (Temp >= H->Elements[Child])
		{
			break;
		}
		else {
			H->Elements[Parent] = H->Elements[Child];
		}
	}
	H->Elements[Parent] = Temp;
	return MaxItem;
}

//构建最大堆
void MaxHeap_PercDown(MaxHeap H, int p)
{
	int Parent, Child;
	ElementType x;
	x = H->Elements[p];
	for (Parent = p; Parent * 2 <= H->size; Parent = Child)
	{
		Child = Parent * 2;
		if ((Child != H->size)&&(H->Elements[Child] < H->Elements[Child+1]))
		{
			Child++;
		}
		if (x >= H->Elements[Child])
		{
			break;
		}
		else {
			H->Elements[Parent] = H->Elements[Child];
		}
	}
	H->Elements[Parent] = x;
}

void Build_MaxHeap(MaxHeap H)
{
	int i;
	for (i = H->size / 2; i > 0; i--)
	{
		MaxHeap_PercDown(H, i);
	}
}

//构建最小堆
void MinHeap_PercDown(MinHeap H, int p)
{
	int Parent, Child;
	ElementType x;
	x = H->Elements[p];
	for (Parent = p; Parent * 2 <= H->size; Parent = Child)
	{
		Child = Parent * 2;
		if ((Child != H->size)&&(H->Elements[Child] > H->Elements[Child+1]))
		{
			Child++;
		}
		if (x <= H->Elements[Child])
		{
			break;
		}
		else {
			H->Elements[Parent] = H->Elements[Child];
		}
	}
	H->Elements[Parent] = x;
}

void Build_MinHeap(MinHeap H)
{
	int i;
	for ( i = H->size/2; i > 0; i--)
	{
		MinHeap_PercDown(H, i);
	}
}

十.并查集

#include<iostream>
using namespace std;
typedef int ElementType;
#define SetType_MaxSize 10001

typedef struct {
	ElementType Data;
	int Parents;
}SetType;

int SetType_Find(SetType S[], ElementType x)
{
	int i;
	for ( i = 0; i < SetType_MaxSize && S[i].Data != x;i++)
	{
		if (i >= SetType_MaxSize)
		{
			return -1;
		}
		for (; S[i].Parents >= 0; i = S[i].Parents);
		return i;
	}
}

void Union(SetType S[], ElementType x1, ElementType x2)
{
	int Root1, Root2;
	Root1 = SetType_Find(S, x1);
	Root2 = SetType_Find(S, x2);
	if (Root1 != Root2)
	{
		S[Root2].Parents = Root1;
	}
}

十一.排序

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef int ElementType;

//冒泡排序
void Bubble_sort(ElementType A[], int N)
{
	for (int p = N - 1; p >= 0; p--)
	{
		int flag = 0;
		for (int i = 0; i < p; i++)
		{
			if (A[i] > A[i + 1])
			{
				swap(A[i], A[i + 1]);
				flag = 1;
			}
		}
		if (flag = 0)
		{
			break;
		}
	}
}

//插入排序
void Insertion_sort(ElementType A[], int N)
{
	int i;
	for (int p = 1; p <	N; p++)
	{
		int Tmp = A[p];
		for (i = p; i > 0 && A[i - 1] > Tmp; i--)
		{
			A[i] = A[i - 1];
		}
		A[i] = Tmp;
		
	}
}

//希尔排序
void Shell_sort(ElementType A[], int N)
{
	int i;
	for (int D = N/2; D > 0; D/=2)
	{
		for (int p = 0; p < N; p++)
		{
			int Tmp = A[p];
			//插入排序
			for (i = p; i >= D && A[i-D] > Tmp; i-=D)
			{
				A[i] = A[i - D];
			}
			A[i] = Tmp;
		}
	}
}

//归并排序
void Merge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd)
{
	int LeftEnd = R - 1;
	int Tmp = L;
	int NumElements = RightEnd - L + 1;
	while (L <= LeftEnd && R <= RightEnd)
	{
		if (A[L] <= A[R])
		{
			TmpA[Tmp++] = A[L++];
		}
		else
		{
			TmpA[Tmp++] = A[R++];
		}
	}
	while (L <= LeftEnd)
	{
		TmpA[Tmp++] = A[L++];
	}
	while (R <= RightEnd)
	{
		TmpA[Tmp++] = A[R++];
	}
	for (int i = 0; i < NumElements; i++, RightEnd--)
	{
		A[RightEnd] = TmpA[RightEnd];
	}
}

void Mosrt(ElementType A[], ElementType TmpA[], int L,int RightEnd)
{
	int Center;
	if (L < RightEnd)
	{
		Center = (L + RightEnd) / 2;
		Mosrt(A, TmpA, L, Center);
		Mosrt(A, TmpA, Center + 1, RightEnd);
		Merge(A, TmpA, L, Center + 1, RightEnd);
	}
}

void Merge_sort(ElementType A[], int N)
{
	ElementType* TmpA;
	TmpA = (ElementType*)malloc(N * sizeof(ElementType));
	if (TmpA != NULL)
	{
		Mosrt(A, TmpA, 0, N - 1);
		free(TmpA);
	}
}

//快速排序
int partition(int l, int r,ElementType A[])            //实现算法思路第二步
{
	int mid = A[l + r >> 1];           //mid为分界点
	int i = l - 1, j = r + 1;          //i和j为左右指针

	while (i < j)                      //利用左右指针完成区间划分
	{
		do i++; while (A[i] < mid);
		do j--; while (A[j] > mid);
		if (i < j) swap(A[i], A[j]);
	}

	return j;
}

void Quicksort(int l, int r,ElementType A[])
{
	if (l == r) return;                //当区间中内只有一个数时返回

	int j = partition(l, r,A);           //将序列划分为左右两区间

	Quicksort(l, j,A);                   //递归处理左区间
	Quicksort(j + 1, r,A);               //递归处理右区间
}


void Quick_sort(ElementType A[], int N)
{
	Quicksort(0,N-1,A);
}
Shibuya_Kanon
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OpenCV实战（2）——OpenCV核心数据结构
盼小辉丶的博客
11-16 4万+
cv::Mat 类是用于保存图像(以及其他矩阵数据)的数据结构，该数据结构是所有 OpenCV 类和函数的核心，这是 OpenCV 库的一个关键元素，用于处理图像和矩阵(从计算和数学的角度来看，图像本质上是一个矩阵)，同时 cv::Mat 数据结构结合了优雅的内存管理机制，因此，使用起来十分高效。本节中，我们介绍了 cv::Mat 结构的基本用法，并且深入探索了创建 cv::Mat 数据结构时的内存分配方式。
数据结构实现（C++版）
11-28
内含资源如下： 1.基本数据结构 1.1.Array ........... 动态数组 1.2.LinkedList ... 链表 1.3.BST .............. 二分搜索树 1.4.MapBST ..... 二分搜索树（用于实现映射） 1.5.AVLTree ...... AVL树 2.接口 2.1.Queue ........... 队列接口 2.2.Stack .............. 栈接口 2.3.Set .................. 集合接口 2.4.Map ............... 映射接口 2.5.Merger .......... 自定义函数接口 2.6.UnionFind ..... 并查集接口 3.高级数据结构 3.1.ArrayQueue .......................... 队列_基于动态数组实现 3.2.LinkedListQueue .................. 队列__基于链表实现 3.3.LoopQueue ........................... 循环队列_基于动态数组实现 3.4.PriorityQueue ....................... 优先队列_基于最大二叉堆实现 3.5.ArrayPriorityQueue ............. 优先队列_基于动态数组实现 3.6.LinkedListPriorityQueue ..... 优先队列_基于链表实现 3.7.ArrayStack ............................. 栈_基于动态数组实现 3.8.LinkedListStack ..................... 栈_基于链表实现 3.9.BSTSet ..................................... 集合_基于二分搜索树实现 3.10.LinkedListSet ....................... 集合_基于链表实现 3.11.BSTMap ................................ 映射_基于二分搜索树实现 3.12.AVLTreeMap ....................... 映射_ 基于AVL树实现 3.13.LinkedListMap .................... 映射_基于链表实现 3.14.MaxHeap ............................. 最大二叉堆 3.15.SegmentTree ...................... 线段树 3.16.Trie ......................................... 字典树 3.17.QuickFind ............................ 并查集_基于数组实现 3.18.QuickUnion ......................... 并查集_基于树思想实现
一些数据结构的实现
Triose_Stream的博客
08-24 843
11988(uva)意思是，你要输入一个字符串，遇到 [ 时按home键， 遇到 ] 时按end键， 然后问你最终这个字符串是什么 SampleInput This_is_a_[Beiju]_text [[]][][]Happy_Birthday_to_Tsinghua_University SampleOutput BeijuThis_is_a__text Happy_Birthday
数据结构基本实现
大道至简
03-31 246
数组 链表 栈 队列 树 图 /** * 深度优先搜索(递归) */ private boolean checkDFS(UndirectedGraphNode a, UndirectedGraphNode b) { if (a == null || b == null) { return false; ...
数据结构实现基础（一）
weixin_47264304的博客
11-19 624
什么是数据结构？ 笔者认为数据结构包括三个部分【1】数据的逻辑结构，即数据对象集【2】数据的物理存储结构，即数据对象集在计算机中的组织方式【3】数据对象集相关联的操作集，以及实现这些操作集的最高效的算法。简而言之，数据结构包含数据逻辑结构，数据物理存储结构，算法。 数据结构往往是抽象的，它的实现需要依赖具体的程序设计语言，一般使用C语言来实现。 例1在日常数据处理中经常碰到的问题是需要对一组数据进行基本的统计分析。比如分析一个班级学生的平均成绩，最高成绩，最低成绩，中位数等。再比如，统计家庭每年每月.
数据结构的基本实现
DropJing的博客
01-28 277
1. python中内置计算算法效率的类 class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=) Timer是测量小段代码执行速度的类。 stmt参数是要测试的代码语句（statment）； setup参数是运行代码时需要的设置； timer参数是一个定时器函数，与平台有关。 timeit.Timer.timeit(number=1000000)...
图解redis五种数据结构底层实现
JavaShark的博客
06-14 2495
redis有五种基本数据结构：字符串、hash、set、zset、list。但是你知道构成这五种结构的底层数据结构是怎样的吗？今天我们来花费五分钟的时间了解一下。(目前redis版本为3.0.6)SDS是"simple dynamic string"的缩写。redis中所有场景中出现的字符串，基本都是由SDS来实现的SDS长这样：free:还剩多少空间 len:字符串长度 buf:存放的字符数组空间预分配为减少修改字符串带来的内存重分配次数，sds采用了“一次管够”的策略：惰性空间释放为避免缩短字符串时候的
数据结构-顺序表结构的实现C语言（全代码）
m0_58441715的博客
01-10 6312
这是数据结构和算法设计课程设计一个选题。实践了顺序表的基本操作的封装，及实践中的调用。特别的对顺序表上的插入和删除操作做出详细的介绍。课设采用静态存储，按值查找。希望能够对其他同学有所帮助
数据结构：图结构的实现
热门推荐
小谷王左的随笔空间
02-07 4万+
图是一种很重要的数据结构，不解释。
数据结构 抽象数据类型的表示与实现
qq_57682820的博客
02-21 2618
抽象数据类型的表示与实现抽象数据类型如何实现算法和算法分析算法 (Algorithm)定义描述算法与程序特性有穷性确定性可行性输入输出算法设计的要求正确性（Correctness）可读性（Readability）健壮性（Robustness）高效性（Efficiency）算法分析目的算法效率算法时间效率的度量两种度量方法事后统计事前分析算法时间复杂度的渐进表示法算法时间复杂度定义 抽象数据类型的表示与实现 抽象数据类型如何实现 **抽象数据类型可以通过固有的数据类型（如整型等）来表示和实现。**即利用处
常见数据结构的实现
08-01
内容包括:链表,循环链表,栈，双向队列，队列的链表实现方式,队列的栈实现方式,排序二叉树的创建，插入，删除，显示，销毁，查找等，带测试函数，所有函数均测试通过，参考的是严蔚敏的数据结构与算法跟算法导论
【数据结构】图的实现
最新发布
qq_53893431的博客
12-01 1504
图的实现和遍历
2.3数据结构的实现
aishizhuang1602的博客
10-30 154
2.3.1简单类型 　　简单类型的变量直接分配内存。可以通过上面的代码非常方便地取得它在内存中的地址及所占用内存的长度。　　短字符串和集合类型，也使用与简单类型一致的规则。　　简单类型的变量在内存中具有特定的格式，比如实数、枚举类型。有关其具体的存储格式，可以查阅参考书目中的《DELPHI技术手册》以及IEEE标准文档。 2.3.2字符串 　　Delphi中的字符串格式多而且混乱。...
数据结构的实现
傻傻的小白
02-18 956
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define Size 5 typedef struct table{ /*每一个顺序表都有其最长长度；当前长度以及地址 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp
数据结构实现
nishuawan的博客
11-15 146
1 并查集（Union/Find） 1.1 并查集（C语言） #include<stdio.h> int f[1001] = { 0 }, n, m, sum = 0; //这里是初始化，非常重要，数组里面存的是自己数组下标的编号 void init() { int i; for (i = 1; i <= n; i++) f[i] = i; return; } /...
数据结构的几种基础实现
筱寒小记
05-30 1115
数据结构的几种基础实现 数据结构是计算机专业的一门重要的基础课，它的教学要求大致有三个重要方面：第一就是让学生学会分析研究计算机加工的数据对象的特性，确定数据的逻辑结构和适当的物理结构；第二，根据结构，设计适当的算法，并初步掌握算法的时间分析和空间分析；第三，学习复杂的程序设计。 实验一、有序表的建立、插入与删除 一、实验目的 1 了解有序表的顺序存储结构。 2 掌握有序表元素在内存中是怎样存储的...
【数据结构】代码实现(线性表、栈、队列、串、树、图)
slience_me的博客
10-24 557
数据结构 一、线性表 1. 顺序表(静态分配) #include <iostream> using namespace std; #define TRUE 1 //逻辑真 #define FALSE 0 //逻辑假 #define OK 1 //正确 #define ERROR 0 //错误 #define INFEASIBLE -1 //不可能，非法操作 #define
常用数据结构的实现
CSDN_XCS的博客
03-29 185
二叉树 （本来是想使用vector<string>以及智能指针 写出一个二叉树的类 来，暂时没成功。如果有大神愿意帮忙给出思路，欢迎评论留言） 构建二叉树 为什么 必须要使用二级指针？参考博文链接 【结论】：必须使用二级指针的本质原因，是因为我们要改变一级指针的值。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值