单链表操作，队列，栈实现，以及常见字符串库函数经典实现

最新推荐文章于 2024-05-28 16:13:50 发布

adr5970

最新推荐文章于 2024-05-28 16:13:50 发布

阅读量134

点赞数

文章标签：数据结构与算法 c/c++ 操作系统

原文链接：http://www.cnblogs.com/ljbguanli/p/6758311.html

版权

立即快要找工作了。数据结构和算法，非常多基础的东西久了没用已经非常不熟练了，必须開始重拾了！

，链表最简单。先从链表入手。后面再写系列的链表面试题总结以及其它数据结构，以下的代码參考了殷人昆老师的教材（数据结构c语言描写叙述）,程序在自己电脑的vc 6.0上能通过。可能有哪些地方不正确的,或者有更精练的实现还指出来大家一起学习~

/************************************************************************/
/*                 (带头结点)单链表的结构及基本操作                                               

 1.迭代打印链表
 2.尾递归打印链表
 3.初始化链表
 4.清空单链表
 5.计算表的长度
 6.推断链表是否为空
 7.在链表中查找值为x的元素
 8.在链表中查找第i个结点
 9.将新元素x插入在链表第i个位置
 10.删除第i个元素
 11.将L2的链表拷贝到L1
 12.前插法建链
 13.尾插法建立链表*/

/************************************************************************/

#include "stdafx.h"
#include <stdlib.h>

//链表的数据类型
typedef int DataType;

//链表的结构定义
typedef struct node
{
	DataType data;	//数据域
	struct node *pNext;	//指针域
}LinkNode, *pNode;

//检測内存分配错误
void MemFail(pNode p)
{
	if (NULL == p)
	{
		printf("内存分配出错!\n");
		exit(1);
	}
}

//1.迭代打印链表
void PrintList(pNode pHead)
{
	pNode p = pHead->pNext;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->pNext;
	}
	printf("\n");
}

//2.尾递归打印链表
void PrintListRecursive(pNode pHead)
{
	if (pHead->pNext != NULL)
	{
		printf("%d ", pHead->pNext->data);
		PrintListRecursive(pHead->pNext);
	}
}

//3.初始化链表
void Initialize(pNode &pHead)
{
	pHead = new LinkNode();
	MemFail(pHead);

	pHead->pNext = NULL;		//这一步easy忘记,链表最后一个结点指针域一定指向Null
}

//4.清空单链表
void ClearList(pNode pHead)
{
	pNode p = NULL;
	while (pHead->pNext != NULL)
	{
		p = pHead->pNext;
		pHead->pNext = p->pNext;
		delete p;
		p = NULL;
	}
}

//5.计算表的长度
int GetLength(pNode pHead)
{
	int counter = 0;
	pNode p = pHead;
	while (p->pNext != NULL)
	{
		p = p->pNext;
		counter++;
	}

	return counter;
}

//6.推断链表是否为空
bool IsEmpty(pNode pHead)
{
	return (NULL == pHead->pNext);
}

//7.在链表中查找值为x的元素,没找到返回null
pNode FindData(pNode pHead, DataType x)
{
	pNode p = pHead->pNext;

	while (p != NULL && p->data != x)
	{
		p = p->pNext;
	}

	return p;
}

//8.在链表中查找第i个结点,假设i不合法,函数返回null
pNode FindPos(pNode pHead, int i)
{
	if (i < 0)
	{
		return NULL;
	}
	
	int counter = 0;

	pNode p = pHead;
	while (p != NULL && counter < i)
	{
		counter++;
		p = p->pNext;
	}

	return p;
}

//9.将新元素x插入在链表第i个位置，若i不合理则返回false,否则返回true
bool InsertEle(pNode pHead, DataType x, int i)
{	
	pNode p = FindPos(pHead, i-1);
	if (NULL == p)		//i不合法
	{		
		return false;
	}

	//新增结点
	pNode pNew = new LinkNode();
	MemFail(pNew);
	pNew->data = x;

	//连接上新结点
	pNew->pNext = p->pNext;
	p->pNext = pNew;

	return true;
}

//10.删除第i个元素,若i不合理则返回false,删除的元素放到x
bool DeleteEle(pNode pHead, int i, DataType &x)
{
	pNode p = FindPos(pHead, i - 1);
	if (NULL == p && NULL == p->pNext)
	{
		return false;
	}

	//删除结点
	pNode pDel = p->pNext;
	x = pDel->data;
	p->pNext = pDel->pNext;
	delete pDel;
	pDel = NULL;
}

//11.将L2的链表拷贝到L1
void Copy(pNode L1, pNode L2)
{
	if (NULL == L1)
	{
		return;
	}

	pNode p2 = L2->pNext;
	pNode p1 = L1;

	while (p2 != NULL)
	{
		pNode pNew = new LinkNode();
		MemFail(pNew);
		pNew->data = p2->data;
		p1->pNext = pNew;	
		p1 = pNew;

		p2 = p2->pNext;
	}
	p1->pNext = NULL;		//这一步易忘
}

//12.前插法建链 即新的元素总是插在头结点后面作为第一个结点
//前插法的结果是数据的输入顺序与链表的顺序相反
//以下这个函数将数组a的内容用前插法进行键链
void InsertFront(pNode pHead, DataType a[], int n)
{
	if (NULL == pHead)		//无效头结点
	{
		return;
	}

	for (int i=0; i<n; i++)
	{
		//生成新结点
		pNode pNew = new LinkNode();
		MemFail(pNew);
		pNew->data = a[i];

		pNew->pNext = pHead->pNext;
		pHead->pNext = pNew;
	}
}

//13.尾插法建立链表 这个结果和上面的函数是相反的
void insertTail(pNode pHead, DataType a[], int n)
{
	if (NULL == pHead)		//头结点不合法
	{
		return;
	}

	pNode pTail = pHead;
	for (int i=0; i<n; i++)
	{
		//生成新结点
		pNode pNew = new LinkNode();
		MemFail(pNew);
		pNew->data = a[i];

		pTail->pNext = pNew;
		pTail = pNew;		
	}
	pTail->pNext = NULL;		//链表收尾
}

以下是基础的栈，和队列操作，vs2005上通过，尽管结构非常easy，但亲自过手才是硬道理！

typedef int dataType;		//栈数据类型
#define MAX_SIZE 10		//栈的最大容量

//静态栈结构定义
struct StaticStack
{
	dataType elem[MAX_SIZE];		//数据
	int top;		//指向栈顶的指针
};

//栈的初始化
void InitializeStaticStack(StaticStack &S)
{
	memset(S.elem, 0, sizeof(dataType) * MAX_SIZE);
	//top始终指向栈顶
	S.top = -1;
}

//将元素x压栈
bool StaticStackPush(StaticStack &S, dataType x)
{
	//栈满
	if (MAX_SIZE - 1 == S.top)
	{
		return false;
	}

	S.elem[++S.top] = x;

	return true;
}

//出栈
bool StaticStackPop(StaticStack &S, dataType &x)
{
	//栈空
	if (-1 == S.top)
	{
		return false;
	}
	
	x = S.elem[S.top--];

	return true;
}

/*
void PrintStaticStack(StaticStack &S)
{
	for (int i=0; i<=S.top; i++)
	{
		printf("%d ", S.elem[i]);
	}
}*/

#define INIT_SIZE 10		//动态栈的初始大小
#define INCREMENT 10	//每次栈扩充的大小

//动态栈结构定义
struct DynamicStack
{
	dataType *elem;		//数据
	int top;		//栈顶指针
	int maxSize;		//栈的最大容量
};

//初始化动态栈
void InitDynamicStack(DynamicStack &S)
{
	S.elem = (dataType *)calloc(INIT_SIZE, sizeof(dataType));
	if (NULL == S.elem)
	{
		printf("Dynamic stack memory initialization error!");
		exit(1);
	}

	S.maxSize = INIT_SIZE;
	S.top = -1;
}

/*
void PrintStaticStack(DynamicStack &S)
{
	for (int i=0; i<=S.top; i++)
	{
		printf("%d ", S.elem[i]);
	}
}*/

//压栈
void DynamicStackPush(DynamicStack &DS, dataType x)
{
	//栈满,须要扩展
	if (DS.top == DS.maxSize - 1)
	{
		DS.elem = (dataType *)realloc(DS.elem, DS.maxSize + INCREMENT);
		if (NULL == DS.elem)
		{
			printf("Expand dynamic stack error!\n");
			exit(1);
		}
	}

	DS.elem[++DS.top] = x;
	DS.maxSize += INCREMENT;
}

//出栈
bool DynamicStackPop(DynamicStack &DS, dataType &x)
{
	//栈空
	if (-1 == DS.top)
	{
		return false;
	}

	x = DS.elem[DS.top--];

	return true;
}



#define QUEUE_SIZE 10		//队列的大小

//循环队列结构定义
struct Queue
{
	dataType elem[QUEUE_SIZE];		//数据
	int front;		//队首指针
	int rear;		//队尾指针
};

//初始化队列
void InitQueue(Queue &Q)
{
	memset(Q.elem, 0, sizeof(dataType) * QUEUE_SIZE);

	Q.front = 0;
	Q.rear = 0;
}

//入队
bool EnQueue(Queue &Q, dataType x)
{
	//队列满
	if ((Q.rear + 1) % QUEUE_SIZE == Q.front)
	{
		return false;
	}

	Q.elem[Q.rear] = x;
	Q.rear = (Q.rear + 1) % QUEUE_SIZE;

	return true;
}

//出队
bool DeQueue(Queue &Q, dataType &x)
{
	//队列空
	if (Q.front == Q.rear)
	{
		return false;
	}
	
	x = Q.elem[Q.front];
	Q.front = (Q.front + 1) % QUEUE_SIZE;

	return true;

}

//返回队列当前大小
int GetQueueSize(Queue &Q)
{
	//注意别忘记加QUEUE_SIZE
	//当Q.rear - Q.front < 0时。须要加QUEUE_SIZE
	//当Q.rear - Q.front > 0时。假设加了QUEUE_SIZE后。须要对QUEUE_SIZE取模
	return (Q.rear - Q.front + QUEUE_SIZE) % QUEUE_SIZE;
}

/*
void PrintQueue(Queue &Q)
{
	for (int i=Q.front; i!=Q.rear; i=(i+1)%QUEUE_SIZE)
	{
		printf("%d ", Q.elem[i]);
	}
	printf("\n");
}
*/

近期把一些常见的c语言的字符串库函数參照着网上的程序自己实现了一下，也是方便自己复习总结，里面的实现比較经典，以下的函数在我电脑vs2005上都能通过。但未进行严格的測试。

/************************************************************************/
/* 1.strcpy函数实现
   2.strncpy实现
   3.strcat函数实现
   4.strncat函数实现
   5.strdup实现
   6.strchr实现
   7.strrchr函数实现
   8.strpbrk函数
   9.strstr实现
   10.strlen实现
   11.strlen还有一种实现
   12.strcmp函数实现
   13.strcmpy的一种标准实现
   14.strncpy函数实现
   15.memset函数实现*/   
/************************************************************************/

1.strcpy函数实现

//功能说明：将source的字符串拷贝到dest来
//dest所指向的空间必须有足够的内存来容纳source所指向的字符串
char * my_strcpy(char *dest, const char *source)
{
	assert(dest!=NULL && source!=NULL);
	char *r = dest;

	//*(dest++),先返回*dest, 然后dest++
	//(*(dest++) = *(source++)返回最左边表达式的值
	while ((*(dest++)=*(source++)) != '\0');

	return r;
}
/*
1.注意參数的命名上规范,让人easy明确怎么使用函数
2.第二个參数类型是const char *,防止改动源字符串
3.函数返回值是char *。能够实现链式表达式
4.參数合法性检查。以下的函数相同要遵循这些
*/

2.strncpy实现

//将source的前n个字符串拷贝到dest
char * my_strncpy(char *dest, const char *source, int n)
{
	assert(dest!=NULL && source!=NULL);

	char *r = dest;

	//注意n--和后面一堆不能换,否则会多复制一个
	while (n-- && (*(dest++)=*(source++))!='\0');

	return r;

}

3.strcat函数实现

//将source指向的字符串链接在dest后面
char * my_strcat(char *dest, const char *source)
{
	assert(dest!=NULL && source!=NULL);

	char *r = dest;

	while (*(dest) != '\0')
	{
		dest++;
	}

	while ((*(dest++)=*(source++)) != '\0');

	return r;	
}

4.strncat函数实现

//将source特定数目字符串链接到dest后面
char * my_strncat(char *dest, const char *source, int n)
{
	assert(dest!=NULL && source!=NULL);

	char *r = dest;

	while (*(dest) != '\0')
	{
		dest++;
	}

	while (n-- && (*(dest++)=*(source++))!='\0');

	return r;	
}

5.strdup实现

//该函数将预先配置内存,然后将制定字符串装入内存
char * my_strdup(const char *pStr)
{
	assert(pStr != NULL);

	char *r = (char *)malloc(strlen(pStr)+1);
	if (NULL == r) 
	{
		printf("Memory Failed!\n");
		exit(1);
	}

	return my_strcpy(r, pStr);

}

6.strchr实现

//函数功能在字符串中查找指定的第一个字符，并返回指向该字符的指针
//若未找到,则返回指向'\0'的字符串指针
char * my_strchr(const char *pStr, char ch)
{
	assert(pStr != NULL);
	while (*pStr!='\0' && *pStr!=ch)
	{
		pStr++;
	}
	return (char *)pStr;
}

7.strrchr函数实现

//函数功能：查找一个字符c在还有一个字符串str中末次出现的位置（也就是从str的右側開始查找字符c首次出现的位置）
char * my_strrchr(const char *pStr, char ch)
{
	assert(pStr != NULL);

	const char *r = NULL;

	while (*pStr != '\0')
	{
		if (*pStr == ch)
		{
			r = pStr;
		}
		pStr++;
	}
	return (char *)r;
}

8.strpbrk函数

//函数功能:在两个字符串中寻找首次共同出现的字符,返回该字符在str1中的地址
char *my_strpbrk(const char *str1, const char *str2)
{
	assert(str1!=NULL && str2!=NULL);

	const char *tmp = str2;

	while (*str1 != '\0' )
	{
		tmp = str2;
		while (*tmp != '\0')
		{			
			if (*str1 == *tmp)
			{
				return (char *)str1; 
			}
			tmp++;
		}

		str1++;
	}
	return NULL;
}

9.strstr实现

//若字符串2包括在字符串1里面，返回它在字符串1中的位置,否则返回NULL
char * my_strstr(const char *strDes, const char *str)
{
	assert(strDes!=NULL && str!=NULL);

	const char *tmpDes = NULL;
	const char *tmpStr = NULL;

	while (*strDes != '\0')
	{
		for (tmpDes=strDes, tmpStr=str; 
			*tmpDes==*tmpStr && *tmpStr!='\0';
			tmpDes++, tmpStr++)
		{}		

		if ('\0' == *tmpStr)
		{
			return (char *)strDes;
		}

		strDes++;
	}

	return NULL;
}

10.strlen实现

//该函数返回字符串长度,不包含后面的'\0'
int my_strlen(const char *str)
{
	assert(str != NULL);

	int k = 0;
	while (++k && *(str++)!='\0');

	return k-1;

}

11.strlen还有一种实现

int my_strlen(const char *str)
{
	assert(str != NULL);

	const char *eos = str;		//eos means end of string
	while (*(eos++) != '\0');

	return (int)(eos - str - 1);
}

12.strcmp函数实现

//两个字符串自左向右逐个字符相比（按ASCII值大小相比較），直到出现不同的字符或遇'\0'为止
//s1>s2,返回值大于0，s1<s2返回值小于0,否则等于0
int my_strcmp(const char *str1, const char *str2)
{
	assert(str1!=NULL && str2!=NULL); 
	
	while (*str1!='\0' && *str2!='\0' && *str1==*str2)
	{
		str1++;
		str2++;
	}

	return (*str1 - *str2);
}

13.strcmpy的一种标准实现

int my_strcmp(const char *str1, const char *str2)
{
	assert(str1!=NULL && str2!=NULL); 

	int ret = 0;
	while (!(ret=*(unsigned char *)str1-*(unsigned char *)str2) && *str2!='\0')
	{
		printf("%c - %c = %d\n", *str1, *str2, *str1-*str2);
		str1++;
		str2++;
	}
	if (ret > 0)
	{
		return 1;
	}
	else if (ret < 0)
	{
		return -1;
	}
	else
	{
		return 0;
	}
}

14.strncpy函数实现

//函数比較两个字符串中前n个字符串大小
int my_strncmp(const char *str1, const char *str2, int n)
{
	assert(str1!=NULL && str2!=NULL); 

	if (n <= 0)
	{
		return 0;
	}

	while (--n && *str1!='\0' && *str1==*str2)
	{
		str1++;
		str2++;
	}

	return (*str1 - *str2);
}

15.memset函数实现

//将指定内存区域的前count个字节设定为指定值
void *my_memeset(void *buffer, int c, unsigned int count)
{
	if (count <= 0)
	{
		return buffer;
	}

	assert(buffer != NULL);
	
	char *p = (char *)buffer;
	while (count--)
	{
		*(p++) = (char)c;
	}
	return buffer;

}

转载于:https://www.cnblogs.com/ljbguanli/p/6758311.html

adr5970

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
单链表操作，队列，栈实现，以及常见字符串库函数经典实现

立即快要找工作了。数据结构和算法，非常多基础的东西久了没用已经非常不熟练了，必须開始重拾了！，链表最简单。先从链表入手。后面再写系列的链表面试题总结以及其它数据结构，以下的代码參考了殷人昆老师的教材（数据结构c语言描写叙述）,程序在自己电脑的vc 6.0上能通过。可能有哪些地方不正确的,或者有更精练的实现还指出来大家一起学习~/*************...
复制链接

扫一扫