C部分代碼

// 2015_11_12.cpp : 定義控制檯應用程序的入口點。
//

#include "stdafx.h"
#define PI 3.14
#include <stdio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
//元素類型
typedef struct
{
    int number;
    char *name;
}ElemType;
//線性表
typedef struct
{
    ElemType *elem;  //存儲數據類型
    int length;      //當前長度
    int listsize;    //當前分配的存儲容量
}SqList;
//判斷鏈表是否爲空
int ListEmpty(SqList &L)
{
    if(L.length == 0)
        return 1;
    return 0;
}
//獲取線性表上第i個元素的值
void GetElem(SqList &L,int i)
{
	if(i<1 || i>L.length+1){
		printf("位置不合法");
		exit(-1);
	}
	printf("Name:%s ,Number:%d\n",L.elem[i-1].name,L.elem[i-1].number);
}
//顯示輸出
void Print(SqList &L)
{
	if(!ListEmpty(L)){
		for(int i = 0;i < L.length;i++){
			printf("Name:%s ,Number:%d\n",L.elem[i].name,L.elem[i].number);
		}
	}else{
		printf("鏈表爲空");
	}
}
//初始化鏈表
void InitList(SqList &L)
{
	L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
	if(!L.elem){
		printf("初始化空間失敗");
		exit(-1);
	}
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
}
//插入元素在i位置
void ListInsert(SqList &L,int i,ElemType e)
{
    if(i<1 || i>L.length+1){
        printf("插入位置不合法！\n");
        exit(0);
    }
    //在原始基礎上增加新的空間
    if(L.length>=LIST_INIT_SIZE){
        ElemType *newBase = (ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newBase)
            exit(0);
        L.elem = newBase;
        L.length+=LISTINCREMENT;
    }
	//指針q指向要插入的位置
    ElemType *q = &(L.elem[i-1]);
	//從第i位置上的元素一次向後移動
    for(ElemType *p = &(L.elem[L.length-1]);p>=q; --p)
        *(p+1) = *p;
	//第i位置上的元素設置爲e
	*q = e;
    ++(L.length);
}
//刪除第i個元素
void ListDelete(SqList &L,int i)
{
	if(i<1 || i>L.length+1){
		printf("位置不合法");
		exit(-1);
	}
	for(ElemType *p = &(L.elem[i-1]);p<&(L.elem[L.length-1]);p++){
		*p = *(p+1);
	}
	L.length--;//元素個數-1
	printf("刪除成功\n");
	Print(L);
}

int menu_1()
{
    printf("Hello world!\n");

	SqList L;//聲明
    InitList(L);
    ElemType e;
    e.name = "Jay";
    e.number = 1;
    ListInsert(L,1,e);
	e.name = "JJ";
	e.number = 2;
	ListInsert(L,2,e);
	Print(L);
	GetElem(L,1);
	ListDelete(L,1);
    return 0;
}



typedef struct LNode
{
	ElemType data; // 數據類型
	LNode *next;   // 後繼指針
	int length;
}LNode,*LinkList;

void CreateLinkList(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//初始化，分配一個元素空間給頭節點
	L->next = NULL;
	L->length = 0;
	LNode *ln = (LNode *)malloc(sizeof(LNode));//給元素分配空間
	ln->data.name = "Js";
	ln->data.number = 3;

	ln->next = L->next;
	L->next = ln;
	L->length++;


	ln = (LNode *)malloc(sizeof(LNode));
	ln->data.name = "Ja";
	ln->data.number = 4;

	ln->next = L->next;
	L->next = ln;
	L->length++;
	printf("Length = %d\n",L->length);
}
void Show(LinkList L)
{
	LinkList head = L;//透指針
	LNode *p = head->next;//第一個元素
	while(p){
		printf("Name=%s,Number=%d\n",p->data.name,p->data.number);
		p = p->next;
	}
}

void LinkListInsert(LinkList L,LNode *ln)
{
	ln->next = L->next;
	L->next = ln; 
}
void LinkListDelete(LinkList L,LNode *ln)
{
	LinkList head = L;
	LNode *p = head->next,*q;
	q = head;
	while(p){
		if( p == ln){
			q->next = p->next;
		}
		q = p;
		p = p->next;
	}
}
void Get_Elem(LinkList L,int n)
{
	LinkList head = L;// 獲取頭指針
	LNode *p = head->next;//鏈表第一個元素
	while(p){
		if((n--)==0){ //如果是第n個元素，那麼輸出
			printf("Name=%s,Number=%d\n",p->data.name,p->data.number);
		}
		p = p->next;//指向下一個元素
	}
}

void menu_2()
{
	LinkList L;
	CreateLinkList(L);
	Show(L);
	Get_Elem(L,1);
	LNode ln;    //已經初始化分配了空間，如果是指針，那麼一定要分配給指針指向的空間
	             //例如：LNode *ln = (LNode *)malloc(sizeof(LNode));//給元素分配空間
	ln.data.name = "Jh";
	ln.data.number = 5;
	LinkListInsert(L,&ln);
	Show(L);
	LinkListDelete(L,&ln); //讓虛參數的指針指向實參的取地址
	Show(L);
}

typedef struct DuLNode
{
	int x;
	DuLNode *prior,*next;
}DiLNode,*DuLinkList;
//判斷鏈表是否爲空
bool isEmpty(DuLinkList L)
{
	if(L->next == NULL)
		return true;
	return false;
}
//顯示鏈表信息
void ShowDuLinkList(DuLinkList L)
{
	if(!isEmpty(L)){  //鏈表不爲空的話
		DuLNode *p = L->next; //p指向第一個節點
		while(p){
			printf("P=%d\n",p->x);
			p = p->next;
		}
	}
}
//插入元素
void DuLinkListInsert(DuLinkList L,DuLNode *dl)
{
	DuLNode *head = L;
	if(head->next == NULL){//當前鏈表爲空的話，將第一個元素加入到頭節點和NULL之間
		dl->next = head->next;
		head->next = dl;
		dl->prior = head;
	}	
	else{              //已經包含元素的話，將該節點插入到頭節點和第一個節點之間
		dl->next = head->next;
		head->next->prior = dl;
		head->next = dl;
		dl->prior = head;
	}
}


//刪除第一個元素
void DuLinkListDelete(DuLinkList L)
{
	DuLNode *s = L->next;
	if(!isEmpty(L)){
		if(s->next){//還有>=2個節點
			s->prior->next = s->next;
			s->next->prior = s->prior;
		}else{
			//只剩一個節點的情況
			L->next = NULL;
		}
		
	}
}


//創建雙鏈表
void CreateDuLinkList(DuLinkList &L)
{
	L = (DuLinkList)malloc(LIST_INIT_SIZE*sizeof(DuLNode));
	L->prior =NULL;
	L->next = NULL;
}
void menu_3()
{
	DuLinkList L;
	CreateDuLinkList(L);      //創建鏈表
	DuLNode dl1,dl2,dl3;      //結構體，直接初始化，內存數據已經存在
	dl1.x = 1;
	DuLinkListInsert(L,&dl1); //插入元素
	dl2.x = 2;
	DuLinkListInsert(L,&dl2);
	dl3.x = 3;
	DuLinkListInsert(L,&dl3);
	ShowDuLinkList(L);         //遍歷鏈表
	DuLinkListDelete(L);       //刪除第一個節點
	ShowDuLinkList(L);
}

#define SElemType int
typedef struct {
	SElemType *base;
	SElemType  *top;
	int stacksize;
}SqStack;

//初始化棧
void InitStack(SqStack &S)
{
	S.base = (SElemType *)malloc(LIST_INIT_SIZE*sizeof(SElemType));
	S.top = S.base;
	S.stacksize = LIST_INIT_SIZE;
}
//獲取棧頂
SElemType GetTop(SqStack S)
{
	return *(S.top-1);
}
//出棧
SElemType Pop(SqStack S)
{
	return *(--S.top);
}
//入棧
void Push(SqStack &S,SElemType e)
{
	if(S.top - S.base>=LIST_INIT_SIZE){
		SElemType *newBase = (SElemType *)realloc(S.base,(S.stacksize+LISTINCREMENT)*sizeof(SElemType));
		S.base = newBase;
		S.top = S.base+S.stacksize;
		S.stacksize+=LISTINCREMENT;
	}
	*S.top++= e;
}

void menu_4()
{
	SqStack S;
	InitStack(S);
	Push(S,2);
	Push(S,3);
	Push(S,4);
	printf("Top :%d\n",GetTop(S));
}

//鏈隊列
typedef struct QNode
{
	SElemType data;
	QNode *next;
}QNode,*QueuePtr;
//隊列頭和尾指針
typedef struct 
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
void Pri()
{
	printf("\n");
}
//初始化隊列
void InitQueue(LinkQueue &L)
{
	//分配初始化空間
	L.front = L.rear = (QueuePtr)malloc(sizeof(QNode));
	L.front->next = NULL;
}
//入隊列
void EnQueue(LinkQueue &L,SElemType e)
{
	QNode *p = (QueuePtr)malloc(sizeof(QNode));//分配空間
	p->data = e;     //獲取值
	p->next = NULL;  //後繼指向NULL；
	L.rear->next = p;//原隊列的隊尾節點的後繼指向p
	L.rear =p;       //設置新隊尾指針
}
//出隊列
SElemType DeQueue(LinkQueue L)
{
	SElemType e;         //保留節點數據
	if(L.front != L.rear){
		QNode *p = L.front->next;
		e = p->data;    //保存刪除的節點的數據
		L.front->next = p->next;
		if(L.rear == p)//如果只有一個節點，刪除之後來年表爲空
			L.front = L.rear;

	}
	return e;
}
//顯示隊列信息
void ShowQueue(LinkQueue L)
{
	if(L.front!=L.rear){      //隊列不爲空
		QNode *p = L.front->next;  //獲取第一個節點
		while(p!=NULL){
			printf("%d ",p->data);
			p = p->next; 
		}
		Pri();
	}else{
		printf("隊列爲空！\n");
	}
}
//銷燬隊列,銷燬所有已經分配的空間，包括F.front指向的空間
void DestoryQueue(LinkQueue &L)
{
	while(L.front){
		L.rear = L.front->next;//隊尾指向第一個元素
		free(L.front);         //釋放第一個空間
		L.front = L.rear;      //同時指向第一個元素
	}
}

void menu_5()
{
	LinkQueue L;
	InitQueue(L);
	EnQueue(L,1);
	EnQueue(L,2);
	EnQueue(L,3);
	ShowQueue(L);
	printf("De:%d\n",DeQueue(L));
	ShowQueue(L);
	DestoryQueue(L);
	ShowQueue(L);

}


//線性循環隊列
#define MAX_SIZE 100
typedef struct 
{
	SElemType *base;
	int front;
	int rear;
}Queue;

//初始化循環隊列
void InitQueue(Queue &Q)
{
	Q.base = (SElemType*)malloc(MAX_SIZE*sizeof(SElemType));
	Q.front = Q.rear = 0;
}
//插入元素
void InsertQueue(Queue &Q,SElemType e)
{
	if((Q.rear+1)%MAX_SIZE == Q.front){
		printf("隊列已滿!\n");
		exit(0);
	}
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MAX_SIZE;
}
//出隊列
void DeQueue(Queue &Q)
{
	if(Q.front == Q.rear){
		printf("隊列爲空!\n");
		exit(0);
	}
	printf("DeQueue %d\n",Q.base[Q.front]);
	Q.front = (Q.front+1)%MAX_SIZE;
}
void menu_6()
{
	Queue Q;
	InitQueue(Q);
	InsertQueue(Q,1);
	InsertQueue(Q,2);
	InsertQueue(Q,3);
	DeQueue(Q);
	DeQueue(Q);
	DeQueue(Q);
}
int _tmain(int argc, _TCHAR* argv[])
{
	cout << PI <<endl;
	menu_1();
	menu_2();
	menu_3();
	menu_4();
	menu_5();
	menu_6();
	return 0;
}