基 础 算 法 总 结（原创）
由 王宇 原创并发布：
算法：数据的组织方法，数据结构是算法的载体。
数据结构包括：数组、链表、树、堆栈、队列
以下代码均在linux 环境下，gcc v4.5 编译调试通过。
排序：
直接插入排序：
时间复杂度：O(N^2)
思想：
R[n] 分成两个序列区：有序区R(j) (j = 0 j<i), 无序区R[i] (i=1...n-1)，将无序区中的元素，插入到有序区适当的位置
实现代码：
#include<stdio.h>
int main()
{
int R[16]={2,5,1,4,8,6,0,9,3,7,11,10,12,15,14,13};
int i,j,temp,n=16,p;
for(i=1;i<n;i++) //R[i=1......n-1] 无序区中遍历
{
for(j=0;j<i;j++) //R[i] 有序区中遍历
{
if(R[j]<R[i]) //比较交换
{
temp=R[j];
R[j]=R[i];
R[i]=temp;
}
}
}
for(p=0;p<n;p++) //打印输出结果
{
printf("%d, ",R[p]);
}
printf("\n");
return 0;
}
希尔插入:
时间复杂度：O(N*(logN)2)
思想：
分治法，直插法：按照步长，进行分组，然后进行各组的插入排序.减少交换次数
实现代码：
#include<stdio.h>
int main()
{
int R[16]={2,5,1,4,8,6,0,9,3,7,11,10,12,15,14,13};
int i,j,temp,n=16,p,step;
/*缩减法，分组*/
for(step = n/2;step > 0;step /= 2)
{
/*直接插入法，排序*/
for(i=step;i<n;i++) //无序区中遍历
{
for(j=i-step;j<i;j++) //有序区中遍历
{
if(R[j]<R[i]) //比较交换
{
temp=R[j];
R[j]=R[i];
R[i]=temp;
}
}
}
}
for(p=0;p<n;p++) //打印输出结果
{
printf("%d, ",R[p]);
}
printf("\n");
return 0;
}
选择排序：
时间复杂度：O(N^2)
思路：
R[n]分成两个序列区：在R[j]序列中选择最小的 (j =i+1 j<n)，放入R[i]位置，作为已经排好的序列.(i = 0 i < n)
实现代码：
#include<stdio.h>
int main()
{
int R[10] = {4,3,5,7,6,2,1,8,9,0};
int i,j,temp,n=10,p;
for(i = 0;i < n;i++) //将选择的值，放在R[i]的位置
{
for(j = i+1;j < n ;j++) //R[n]序列中选择最小的
{
if(R[j] > R[i]) //比较交换
{
temp=R[j];
R[j]=R[i];
R[i]=temp;
}
}
}
for(p=0;p < n;p++) //打印输出结果
{
printf("%d",R[p]);
}
printf("\n");
return 0;
}
冒泡排序：
时间复杂度：O(N^2)
思路：
R[n]序列，i=0,R[i]同R[i+1]比较，交换n-1次
#include<stdio.h>
int main()
{
int R[10]={7,3,8,4,9,5,6,2,1,0};
int i,j,n=10,p,q,temp;
for(i=n-1;i>0;i--) //n-1次交换
{
for(j=0;j<i;j++) // i=0 R[i] 同 R[i+1]比较
{
q=j+1;
if(R[q]>R[j]) //比较交换
{
temp=R[j];
R[j]=R[q];
R[q]=temp;
}
}
}
for(p=0;p<n;p++)//打印输出结果
{
printf("%d",R[p]);
}
printf("\n");
return 0;
}
快递排序 （不稳定排序）：
时间复杂度：O(N*LogN)
思路：分治法，基准法：R[n]中找到基准点pivot，分成左右两个区域R[0..pivot-1] R[pivot+1..n-1]，一部分的所有数据，要比另一部分的数据都小,递归解决
#include<stdio.h>
/*递归，分治*/
void quickSort(int *R,int low,int height)
{
int pivot;
if(low<height)
{
pivot=partition(R,low,height); //寻找基准
quickSort(R,low,pivot-1); //R[0..pivot-1]
quickSort(R,pivot+1,height); //R[pivot+1..n-1]
}
}
/*基准法*/
int partition(int *R,int i,int j)
{
int pivot=R[i];
while(i<j)
{
while(i<j && pivot<R[j] ) //从左向右同基准比较并移动交换
{
j--;
}
if(i<j) R[i++]=R[j];
while(i<j && pivot>R[i]) //从右向左同基准比较并移动交换
{
i++;
}
if(i<j) R[j--]=R[i];
}
R[i]=pivot;
return i;
}
int main()
{
int R[10]={0,2,8,4,7,3,6,5,1,9};
int p;
quickSort(R,0,9); //调用快速排序
for(p=0;p<10;p++) //打印输出结果
{
printf("%d",R[p]);
}
printf("\n");
return 0;
}
归并排序 （稳定排序）：
思路：
归并,二分法(递归)
归并操作：
R[n]无序队列m处分两组R[0..m]R[m+1...n-1]申请长度n的空间R1[n]
对比两个分组，将较小的先放入R1
将第一组剩余的放入R1
将第二组剩余的放入R1
将R1复制回R中
#include<stdio.h>
#include<stdlib.h>
void merge(int *R,int low,int mid,int high)
{
int i=low,j=mid+1,p=0;
int *R1;
R1=(int *)malloc((high-low+1)*sizeof(int));
if(!R1) perror("error:malloc");
while(i<=mid && j<=high) //对比两个分组，将较小的先放入R1
{
R1[p++]=(R[i]<R[j]) ? R[i++] : R[j++];
}
while(i<=mid) //将第一组剩余的放入R1
{
R1[p++]=R[i++];
}
while(j<=high) //将第二组剩余的放入R1
{
R1[p++]=R[j++];
}
for(i=low,p=0;i<=high;i++,p++) // 将R1复制回R中
{
R[i]=R1[p];
}
free(R1);
}
void mergeSort(int *R,int first,int last)
{
int mid;
if(first<last)
{
mid=(last+first)/2; //二分法
mergeSort(R,first,mid); //R[low..m]递归分治
mergeSort(R,mid+1,last);//R[m+1...hight]递归分治
merge(R,first,mid,last); //归并操作
}
}
int main()
{
int R[10]={5,0,9,3,8,2,7,1,6,4};
int i,j,temp,p,n=10;
mergeSort(R,0,9); //调用归并算法
for(p=0;p<n;p++) //打印输出结果
{
printf("%d",R[p]);
}
printf("\n");
return 0;
}
二叉树
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define MAX_CNT 5
typedef struct Tree_Struct{
int key;
struct Tree_Struct * left;
struct Tree_Struct * right;
}Tree_Struct;
void make_node(int target,Tree_Struct ** ppTree){
Tree_Struct * pTree_m=(Tree_Struct *)malloc(sizeof(Tree_Struct));
if(!pTree_m) perror("malloc error!");
pTree_m->key = target;
pTree_m->left = NULL;
pTree_m->right = NULL;
*ppTree=pTree_m;
}
void insert_node(Tree_Struct ** ppNode,int target){
Tree_Struct * node = *ppNode;
if(node == NULL){
make_node(target,&node);
*ppNode = node;
return;
}
if(node->key == target){
return;
}else if(node->key > target){
insert_node(&node->left,target);
*ppNode = node;
return;
}else{
insert_node(&node->right,target);
*ppNode = node;
return;
}
}
int get_high(Tree_Struct ** ppNode){
int left_high=0,right_high=0;
Tree_Struct * tree = *ppNode;
if(tree == NULL){
return 0;
}else{
left_high = get_high(&tree->left);
right_high = get_high(&tree->right);
return left_high > right_high ? left_high+1 : right_high+1;
}
}
void pre_order(Tree_Struct * root){
if(root != NULL){
printf("%d ",root->key);
pre_order(root->left);
pre_order(root->right);
}else{
printf(" # ");
}
}
void in_order(Tree_Struct * root){
if(root != NULL){
in_order(root->left);
printf("%d ",root->key);
in_order(root->right);
}else{
printf(" # ");
}
}
void post_order(Tree_Struct * root){
if(root != NULL){
post_order(root->left);
post_order(root->right);
printf("%d ",root->key);
}else{
printf(" # ");
}
}
int main(){
int i,high=0,srand_int=0;
Tree_Struct * root=NULL;
srand((unsigned)time(NULL));
printf("Original number list : ");
for(i=0;i<MAX_CNT;i++){
srand_int = rand() % 100;
printf("%d ",srand_int);
insert_node(&root,srand_int);
}
//前序
printf("\nPer Order:\n");
pre_order(root);
printf("\n");
//中序
printf("In Order:\n");
in_order(root);
printf("\n");
//后序
printf("Post Order:\n");
post_order(root);
printf("\n");
//层高
printf("Tree level high:");
high = get_high(&root);
printf("%d \n",high);
return 0;
}
单链表等待序
查找：