算法

算法是特定问题求解步骤的描述，在计算机中表示为指令的有限序列，算法是独立存在的一种解决问题的方法和思想。

对于算法而言，语言不重要，重要的是思想。

算法具有五个基本的特性：输入、输出、有穷性、确定性和可行性

算法和数据结构的区别

算法是为了解决实际问题而设计的
数据结构是算法需要处理的问题载体
数据结构与算法相辅相成

数据结构分类

数据结构分为逻辑结构（集合结构，线性结构，树形结构，图形结构）和物理结构/存储结构（顺序存储，链式存储）

线性 1：1关系除了第一个元素没有前驱，最后一个元素没有后继，其他元素都有唯一的前驱和唯一的后继。

树形 1：n关系

图形 n：n关系

线性表

动态数组

初始化，插入数据，遍历数据，

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>//动态数组的结构体
struct dynamicArray
{void ** pAddr;//维护在堆区真实数组指针int m_capacity;//数组容量int m_size;//数组大小
};
//初始化数组
struct dynamicArray * init_DynamicArray(int capacity)
{if (capacity <= 0){return NULL;}struct dynamicArray * array = (dynamicArray*)malloc(sizeof(struct dynamicArray));//判断内存是否申请成功if (array == NULL){return NULL;}//设置容量array->m_capacity = capacity;//设置大小array->m_size = 0;//维护在堆区数组的指针array->pAddr =(void**)  malloc(sizeof(void*) * array->m_capacity);return array;
}
//插入功能
void insert_dynamicArray(struct dynamicArray* array, int pos, void* data)
{if (array == NULL){return;}if (data == NULL){return;}if (pos < 0 || pos>array->m_size){//无效的位置  进行尾插pos = array->m_size;}//先判断是否已经满载，满了就动态开辟if (array->m_size >= array->m_capacity){//申请一个更大的空间int newCapacity = array->m_capacity * 2;//创建新空间void** newSpace = (void**) malloc(sizeof(void*) * newCapacity);//将原来的数据拷到新空间memcpy(newSpace, array->pAddr, sizeof(void*) * array->m_capacity);//释放原有的空间free(array->pAddr);//更改指针指向array->pAddr = newSpace;//更新容量大小array->m_capacity = newCapacity;}//插入新数据,从最后一个数据 依次后移for (int i = array->m_size - 1; i >= pos; i--){array->pAddr[i + 1] = array->pAddr[i];}//将新元素插入指定位置array->pAddr[pos] = data;//更新size大小array->m_size++;}
//遍历数组
void foreach_DynamicArray(struct dynamicArray* array,void (*myForeach)(void*))
{if (array == NULL) {return;}if (myForeach == NULL) {return;}for (int i = 0; i < array->m_size; i++) {myForeach(array->pAddr[i]);}
}
//删除数组中元素 按照指定位置
void removebyPos_DynamicArray(struct dynamicArray * arr,int pos)
{if (arr == NULL) {return;}if (pos<0 || pos>arr->m_size - 1) {//无效位置return;}for (int i = pos; i < arr->m_size - 1; i++)//从pos位置开始到数组尾  数据前移{arr->pAddr[i] = arr->pAddr[i + 1];}arr->m_size--;
}
//删除数组中元素 按照值
void removebyvalue_DynamicArray(struct dynamicArray * arr,void*  data,int (*myCompare)(void*,void*)) {if (arr == NULL||data==NULL) { return; }for (int i = 0; i < arr->m_size; i++) {if (myCompare(arr->pAddr[i], data)) {removebyPos_DynamicArray(arr, 1);break;}}
}
//销毁
void destroy_DynamicArray(struct dynamicArray * arr) {if (arr == NULL) { return; }if (arr ->pAddr != NULL) {free(arr->pAddr);arr->pAddr = NULL;}free(arr);arr = NULL;
}struct Person {char name[64];int age;
};
void myPrintPerson (void * data) {struct Person * p =(Person*) data;printf("姓名,%s 年龄%d\n", p->name, p->age);}
int myComparePerson(void* data1,void*data2) {struct Person* p1 =(Person*) data1;struct Person* p2 = (Person*)data2;return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}
void test01() {//创建动态数组struct  dynamicArray* arr = init_DynamicArray(5);struct Person p1 = { "a",18 };struct Person p2 = { "b",15 };struct Person p3 = { "c",28 };struct Person p4 = { "d",13 };struct Person p5 = { "e",16 };struct Person p6 = { "f",19 };//将数据插入动态数组中printf("当前的容量为:%d\n", arr->m_capacity);insert_dynamicArray(arr, 0, &p1);insert_dynamicArray(arr, 0, &p2);insert_dynamicArray(arr, 0, &p3);insert_dynamicArray(arr, 0, &p4);insert_dynamicArray(arr, 0, &p5);insert_dynamicArray(arr, 0, &p6);// f e d c b a//遍历foreach_DynamicArray(arr, myPrintPerson);printf("插入数据后的容量为：%d\n", arr->m_capacity);//删除removebyPos_DynamicArray(arr, 1);printf("删除第一个位置的元素");foreach_DynamicArray(arr, myPrintPerson);struct Person p = { "f",19 };removebyvalue_DynamicArray(arr, &p, myComparePerson);printf("------------------------------");foreach_DynamicArray(arr, myPrintPerson);//销毁destroy_DynamicArray(arr);arr = NULL;
}
; int main() {test01();system("pause");return EXIT_SUCCESS;
}

单向链表

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>//链表结点
struct LinkNode {void* data;//数据域struct LinkNode* next;//指针域
};
//链表结构体
struct LList {struct LinkNode pHeader;//头节点int m_size;//链表长度
};typedef void* LinkList;
//初始化链表
LinkList init_LinkList() {struct LList* myList = (LList* )malloc(sizeof(struct LList));if (myList == NULL) {return NULL;}myList->pHeader.data = NULL;myList->pHeader.next = NULL;myList->m_size =0;return myList;
}
//插入结点
void insert_LinkList(LinkList list, int pos, void* data) {if (list == NULL || data == NULL) { return; }struct LList* myList =(LList *) list;if (pos < 0||pos> myList->m_size) {//无效位置  尾插pos = myList->m_size;}//创建临时节点struct LinkNode* pCurrent = &myList->pHeader;//通过循环找到插入位置的前驱结点 for (int i = 0; i < pos; i++) {pCurrent = pCurrent->next;}//创建新结点struct LinkNode*newNode = (LinkNode*)malloc(sizeof(struct LinkNode));newNode->data = data;newNode->next= NULL;//新结点插入链表中newNode->next = pCurrent->next;pCurrent->next = newNode;myList->m_size++;//更新链表长度}
//遍历链表
void foreach_LinkList(LinkList list ,void (*myPrint)(void*) ) {if(list == NULL) { return; }struct LList* myList = (LList*)list;struct LinkNode* pCurrent = myList->pHeader.next;//找到第一个有数据的结点for (int i = 0; i < myList->m_size; i++) {myPrint(pCurrent->data);pCurrent = pCurrent->next;}
}
//删除结点
void removeby_LinkList(LinkList list, int pos) {if (list == NULL) { return; }struct LList* myList =(LList*) list;if (pos<0||pos>myList->m_size-1) {return;}
//找到删除结点前驱struct LinkNode* pCurrent = &myList->pHeader;for (int i = 0; i < pos; i++) {pCurrent = pCurrent->next;}//缓存中  待删除struct LinkNode* pDel = pCurrent->next;//建立关系pCurrent->next = pDel->next;//释放free(pDel);pDel = NULL;//更新长度myList->m_size--;
}
//删除 值
void removebyValue_LinkList(LinkList list,void* data,int (*myCompare)(void*,void*) ) {if (list == NULL||data==NULL) { return; }struct LList* myList =(LList*) list;//创建两个辅助指针变量struct LinkNode* pPrev =  &myList->pHeader;struct LinkNode* pCurrent = pPrev->next;for (int i = 0; i < myList->m_size; i++) {//给用户来对比if (myCompare(pCurrent->data, data)) {//更改指针指向pPrev->next = pCurrent->next;//释放free(pCurrent);pCurrent = NULL;myList->m_size--;break;}//后移pPrev = pCurrent;pCurrent=pCurrent->next;}
}
//清空
void clear_LinkList(LinkList list) {if (list == NULL) { return; }struct LList* myList =(LList*) list;struct LinkNode* pCurrent= myList->pHeader.next;for (int i = 0; i < myList->m_size;i++) {//记录后继结点struct LinkNode* pNext =(LinkNode*) pCurrent->next;free(pCurrent);pCurrent = pNext;}myList->pHeader.next = NULL;myList->m_size = 0;
}
//返回长度
int size_LinkList(LinkList list) {if (list == NULL) { return -1; }struct LList* myList =(LList*) list;return myList->m_size;
}
//销毁
void destroy_LinkList(LinkList list) {if (list == NULL) { return; }clear_LinkList(list);free(list);list = NULL;
}struct Person {char name[64];int age;
};
void myPPerson(void* data) {struct Person* p = (Person*)data;printf("字母: %s 数字: %d\n", p->name, p->age);
}
int myCompare(void* data1, void * data2) {struct Person* p1 = (Person*) data1;struct Person* p2 = (Person*) data2;return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}
//调试
void test01() {//初始化LinkList list = init_LinkList();//插入数据struct Person p1 = { "a",18 };struct Person p2 = { "b",15 };struct Person p3 = { "c",28 };struct Person p4 = { "d",13 };struct Person p5 = { "e",16 };struct Person p6 = { "f",19 };//插入数据insert_LinkList(list, 0, &p1);insert_LinkList(list, 0, &p2);insert_LinkList(list, 1, &p3);insert_LinkList(list, 0, &p4);insert_LinkList(list, 1, &p5);insert_LinkList(list, 100, &p6);// d e b c a f printf("长度为： %d\n", size_LinkList(list));foreach_LinkList(list, myPPerson);//删除cremoveby_LinkList(list, 3);printf("------------------\n");foreach_LinkList(list, myPPerson);printf("长度为： %d\n", size_LinkList(list));//删除estruct Person p = { "e", 16 };removebyValue_LinkList(list, &p, myCompare);printf("------------------\n");foreach_LinkList(list, myPPerson);printf("长度为： %d\n", size_LinkList(list));//清空clear_LinkList(list);printf("------------------\n");foreach_LinkList(list, myPPerson);//销毁destroy_LinkList(list);
}int main() {test01();system("pause");return EXIT_SUCCESS;
}

栈

属于 先进后出的数据结构。一种特殊的线性表，始终在栈顶进行。

不能遍历(只有栈顶元素被外界访问到)

栈的顺序存储（数组）和栈的链式存储（链表）。

顺序结构

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>#define MAX 1024
//栈的结构体
struct SStack {void* data[MAX];//数组//元素个数int m_size;
};
typedef void* seqStack;
//初始化
seqStack init_SeqStack() {struct SStack* stack = (SStack*)malloc(sizeof(struct SStack));if (stack == NULL) { return NULL; }//清空数组memset(stack->data, 0, sizeof(void*) * MAX);stack->m_size = 0;return stack;
}
//入栈
void push_SeqStack(seqStack stack, void* data) {if (stack == NULL||data==NULL) { return; }//判断是否栈满struct SStack* myStack = (SStack*) stack;if (myStack->m_size == MAX) {return;}myStack->data[myStack->m_size] = data;//尾插 myStack->m_size++;//更新大小
}
//出栈
void pop_SeqStack(seqStack stack ) {if (stack == NULL  ) { return; }struct SStack* myStack = (SStack*)stack;if (myStack->m_size <= 0) { return; }myStack->data[myStack->m_size - 1] = NULL;//执行出栈myStack->m_size--;//更新大小
}
//获取栈顶元素
void* top_SeqStack(seqStack stack) {if (stack == NULL) { return NULL; }struct SStack* myStack = (SStack*)stack;if (myStack->m_size == 0) { return NULL; }return myStack->data[myStack->m_size-1];
}
//栈的大小
int size_SeqStack(seqStack stack) {if (stack == NULL) { return -1; }struct SStack* myStack = (SStack*)stack;return myStack->m_size;
}
//判空
int isEmpty_SeqStack(seqStack stack) {if (stack == NULL) { return -1; }//真struct SStack* myStack = (SStack*)stack;if (myStack->m_size <= 0) {return 1;//真}return 0;//假，不为空
}
//销毁
void destroy_SeqStack(seqStack stack){if (stack == NULL) { return ; }free(stack);stack = NULL;
}
//测试
struct Person {char name[64];int age;
};
void test() {//数据struct Person p1 = { "aaa",10 };struct Person p2 = { "bbb",20 };struct Person p3 = { "ccc",30 };struct Person p4 = { "ddd",40 };struct Person p5 = { "eee",50 };//初始化栈seqStack init_SeqStack();//入栈//出栈//。。。}
; int main() {void test();system("pause");return EXIT_SUCCESS;
}

数据结构和算法（C语言）相关推荐

《数据结构与算法 C语言版》—— 3.8习题
本节书摘来自华章出版社<数据结构与算法 C语言版>一书中的第3章,第3.8节,作者:徐凤生,更多章节内容可以访问云栖社区"华章计算机"公众号查看. 3.8习题 1名 ...
《数据结构与算法 C语言版》—— 2.5上机实验
本节书摘来自华章出版社<数据结构与算法 C语言版>一书中的第2章,第2.5节,作者:徐凤生,更多章节内容可以访问云栖社区"华章计算机"公众号查看. 2.5上机实验实 ...
《数据结构与算法 C语言版》—— 2.7习题
本节书摘来自华章出版社<数据结构与算法 C语言版>一书中的第2章,第2.7节,作者:徐凤生,更多章节内容可以访问云栖社区"华章计算机"公众号查看. 2.7习题 1描 ...
java递归单链表查找中间元素_《数据结构与算法——C语言描述》答案 3.11 查找单链表中的特定元素（递归）...
转载请注明出处:http://blog.csdn.net/xdz78 #include #include //查找单链表中的特定元素,<数据结构与算法--c语言描述> 3.11 答案 in ...
数据结构与算法python描述_数据结构与算法——Python语言描述.pdf
数据结构与算法--Python语言描述.pdf 欢迎加入非盈利Python编学习交流程QQ群783462347,群里免费提供500+本Python书籍! 欢迎加入非盈利Python编程学习交流程QQ群 ...
《数据结构与算法 Python语言描述》读书笔记
已经发布博客 <数据结构与算法 Python语言描述> 读书笔记第二章抽象数据类型和Python类 2.1 抽象数据类型abstract data type:ADT 2.1.1 使用编 ...
《数据结构与算法 Python语言实现》书评与学习心得
做为Python小白,本人几个月前读完了Mark Lutz的1400页巨著<Learning Python>(太TM啰嗦了,读过的请举手),本打算继续学习下一步<Programmin ...
数据结构视频教程 -《[猎豹网校]数据结构与算法_C#语言》
整个视频打包下载地址:史上最全的数据结构视频教程系列分享之<[猎豹网校]数据结构与算法_C#语言>,转载请保留出处和链接! 更多优秀资源请访问:我是码农在猎豹网校授课的基本都是在IT行业 ...
数据结构与算法python语言实现-第四章答案
数据结构与算法python语言实现-第四章答案 4.1 def findmax(S, index=0):if index == len(S) - 1:return S[index]max=findma ...
数据结构python课后答案_数据结构与算法:Python语言描述 1~5章课后习题
数据结构与算法:Python语言描述 1~5章课后习题发布时间:2018-07-19 20:42, 浏览次数:1885 , 标签: Python MarkDown语法写的,不知道为啥上传到CSDN不 ...

数据结构和算法（C语言）

算法

算法和数据结构的区别

数据结构分类

线性表

动态数组

单向链表

栈

数据结构和算法（C语言）相关推荐

最新文章

热门文章