二叉排序树建立动态查找表

2017-1/Cloud/1.线性表的基本操作/LinkList.c

@@ -0,0 +1,69 @@
+#include "LinkList.h"
+
+/* �����ı��� */
+void TraverseList(LinkList p) {
+	LinkList l = p;
+	l = l->next;
+	while ( l != p) {
+		printf("%d ",l->data);
+		l = l->next;
+	}
+	printf("\n");
+}
+
+/* �������� */
+LinkList CreatList( int n) {
+	LNode *L,* p;
+	int i;
+	L = (LinkList)malloc(sizeof(LNode));
+	L->next = L;
+	L->data = n;
+	if (!L)
+		exit(1);
+	for (i = 0; i < n ; i++) {
+		p = (LinkList)malloc(sizeof(LNode));
+		if (!p)
+			exit(1);
+		p->data = i;
+		p->next = L->next;
+		L->next = p;
+	}
+	return L;
+}
+
+/*��ʼ������*/
+void InitList(LinkList a) {
+	LinkList p = a;
+	for (; p->next != a; p = p->next) {
+		p->data = 0;
+
+	}
+}
+
+/* ������� */
+void SeparateList(LinkList A, LinkList b, LinkList c) {
+//�㷨�������㷨�ĵ�ʱ�临�Ӷ�Ϊ O��n�����ռ临�Ӷ�ΪO��1����
+//�ڱ�֤�㷨����ȷ�Ե�ǰ���£�ʹ�������ٵ�ʱ�临�ӶȺ����ٵĿռ临�Ӷ�
+	LinkList p = A,p1 = b,p2 = c;
+	InitList(b);
+	InitList(c);
+	p = p->next;
+	p1 = p1->next;
+	p2 = p2->next;
+	while ( p != A) {
+		p1->data = p->data;
+		b->data++;
+		p1 = p1->next;
+		p = p->next;
+		if (p != A) {
+			p2->data = p->data;
+			c->data++;
+			p2 = p2->next;
+			p = p->next;
+		}
+	}
+	return;
+}
+
+
+

2017-1/Cloud/1.线性表的基本操作/LinkList.h

@@ -0,0 +1,30 @@
+#pragma once
+#ifndef LINKLIST_H
+#define LINKLIST_H
+#include<stdio.h>
+#include<stdlib.h>
+#define length 10
+
+typedef  struct LNode {
+	int data;
+	struct LNode *next;
+}LNode, *LinkList;
+
+typedef enum {
+	true,
+	false
+}bool;
+
+/* �����ı��� */
+void TraverseList(LNode * p);
+
+/* �������� */
+LinkList CreatList(int n);
+
+/* ������� */
+void SeparateList(LinkList A, LinkList b, LinkList c);
+
+/*��ʼ������*/
+void InitList(LinkList);
+
+#endif

2017-1/Cloud/1.线性表的基本操作/main_LinkList.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include "LinkList.h"
+#define length 20
+int main() {
+	LinkList A = CreatList(length),
+		a1 = CreatList(length/2),
+		a2 = CreatList(length/2);
+	TraverseList(A);
+	SeparateList(A, a1, a2);
+	TraverseList(a1);
+	TraverseList(a2);
+	return 0;
+}

2017-1/Cloud/1.线性表的基本操作/main_LinkList.txt

@@ -0,0 +1,3 @@
+19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 
+19 17 15 13 11 9 7 5 3 1 
+18 16 14 12 10 8 6 4 2 0 

2017-1/Cloud/2.栈和队列的基本操作/Queue.c

@@ -0,0 +1,106 @@
+#pragma once
+#include "Queue.h"
+
+/*��ʼ������*/
+Status InitQueue(LinkQueue *q) {
+	q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));
+	if (!q->front) {
+		exit(OVERFLOW);
+	}
+	q->front->next = NULL;
+	q->rear->next = NULL;
+	return OK;
+}
+
+/*����һ��Ԫ�أ���e������ֵ*/
+Status EnQueue(LinkQueue *q, QElemType e) {
+	QueuePtr p;
+	p = (QueuePtr)malloc(sizeof(QNode));
+	if (!p) {
+		return OVERFLOW;
+	}
+	p->data = e;
+	p->next = NULL;
+	q->rear->next = p;
+	q->rear = p;
+	return OK;
+}
+
+/*�������Ƿ�Ϊ��*/
+bool QueueEmpty(LinkQueue q) {
+	if (q.front == q.rear) {
+		return true;
+	}
+	else {
+		return false;
+	}
+}
+
+/*ɾ����ͷԪ�أ� ��e������ֵ*/
+Status DeQueue(LinkQueue *q, QElemType *e) {
+	if (QueueEmpty(*q)) {
+		return ERROR;
+	}
+	QueuePtr p;
+	p = q->front->next;//q->frontΪͷ�ڵ㣬q->front->nextΪ��ͷԪ��
+	e = p->data;
+	q->front->next = p->next;
+	if (q->rear == p)//���ɾ�����Ƕ��е����һ��Ԫ�أ���Ҫ�޸�βָ��
+		q->rear = q->front;
+	return OK;
+}
+
+/*��������*/
+Status TraverseQueue(LinkQueue q) {
+	QueuePtr p;
+	if (QueueEmpty(q)) {
+		printf("������\n");
+		return OK;
+	}
+	p = q.front->next;
+	while (p != q.rear) {
+		printf("%d ", p->data);
+		p = p->next;
+	}
+	printf("%d", p->data);
+	printf("\n");
+	return OK;
+}
+
+/*���ٶ���*/
+Status DestroyQueue(LinkQueue *q) {
+	while (q->front) {
+		q->rear = q->front->next;
+		free(q->front);
+		q->front = q->rear;
+	}
+	return OK;
+}
+
+/*������q���Ϊ�ն���*/
+Status ClearQueue(LinkQueue *q) {
+	if (!QueueEmpty(*q)) {
+		q->rear = q->front;
+		return OK;
+	}
+	return false;
+}
+
+/*���ض��еij���*/
+int QueueLength(LinkQueue *q) {
+	int l;
+	QueuePtr lq;
+	for (l = 0, lq = q->front->next; lq != q->rear; l++) {
+		lq = lq->next;
+	}
+	return l + 1;
+}
+
+/*���ض��еĶ�ͷԪ��*/
+Status GetHead(LinkQueue *q, QElemType *e) {
+	if (!QueueEmpty(*q)) {
+		*e = q->front->next->data;
+		return OK;
+	}
+	return false;
+}

2017-1/Cloud/2.栈和队列的基本操作/Queue.h

@@ -0,0 +1,43 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+typedef int QElemType;
+typedef enum {
+	false,
+	true,
+}bool;
+typedef enum {
+	OK,
+	ERROR,
+	OVERFLOW
+} Status;
+typedef struct QNode {
+	QElemType data;
+	struct QNode *next;
+}QNode, *QueuePtr;
+typedef struct _LinkQueue {
+	QueuePtr front;
+	QueuePtr rear;
+}LinkQueue;
+
+/*��ʼ������*/
+Status InitQueue(LinkQueue *q);
+/*����һ����㣬��e������ֵ*/
+Status EnQueue(LinkQueue *q, QElemType e);
+/*�������Ƿ�Ϊ��*/
+bool QueueEmpty(LinkQueue q);
+/*ɾ��һ����㣬 ��e������ֵ*/
+Status DeQueue(LinkQueue *q, QElemType *e);
+/*��������*/
+Status TraverseQueue(LinkQueue q);
+/*���ٶ���*/
+Status DestroyQueue(LinkQueue *q);
+/*������q���Ϊ�ն���*/
+Status ClearQueue(LinkQueue *q);
+/*���ض��еij���*/
+int QueueLength(LinkQueue *q);
+/*���ض��еĶ�ͷԪ��*/
+Status GetHead(LinkQueue *q, QElemType *e);
+#endif 

2017-1/Cloud/2.栈和队列的基本操作/main.c

@@ -0,0 +1,36 @@
+#include<stdio.h>
+#include "Queue.h"
+int main() {
+	int _queueLen;
+	QElemType _e;
+	LinkQueue lk;
+	printf("���г�ʼ��...\n");
+	InitQueue(&lk);
+	printf("��������");
+	TraverseQueue(lk);
+	printf("\n�����µ�Ԫ�� 2\n�������У�");
+	EnQueue(&lk, 2);
+	TraverseQueue(lk);
+	printf("\n�����µ�Ԫ�� 4\n�������У�");
+	EnQueue(&lk, 4);
+	TraverseQueue(lk);
+	printf("\n�����µ�Ԫ�� 6\n�������У�");
+	EnQueue(&lk, 6);
+	TraverseQueue(lk);
+
+	GetHead(&lk, &_e);
+	_queueLen = QueueLength(&lk);
+	printf("\n*��ǰͷ�ڵ�Ϊ %d �����г���Ϊ %d \n", _e, _queueLen);
+	DeQueue(&lk, &_e);
+	printf("\nɾ����ͷԪ�� %d \n�������У�", _e);
+	TraverseQueue(lk);
+
+	GetHead(&lk, &_e);
+	_queueLen = QueueLength(&lk);
+	printf("\n*��ǰͷ�ڵ�Ϊ %d �����г���Ϊ %d \n", _e, _queueLen);
+	ClearQueue(&lk);
+	printf("\n��ն���...\n�������У�");
+	TraverseQueue(lk);
+	DestroyQueue(&lk);
+	return 0;
+}