Kunikida的专栏

//结点结构typedef struct Node{ int data; Node *next;}LinkList;//删除结点void DeleteNode(LinkList *L,int data){ LinkList *p,*p1; p=L; p1=p->next; if(!p1){ printf("LinkList Empty"); exit(1);

在二元树中找出和为某一值的所有路径（树）题目：输入一个整数和一棵二元树。从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。打印出和与输入整数相等的所有路径。例如 输入整数22和如下二元树   10     / \    5  12    / \      4   7   则打印出两条路径：10, 12和10, 5, 7#include#

冒泡排序是稳定的排序，但是算法复杂度较高，平均和最差都是：O(n^2)，空间复杂度为：O(1)#includevoid bubble_sort(int a[],int n){ int i,j,tmp; for(i=0;i<n-1;i++) { for(j=0;j<n-i-1;j++) { if(a[j]>a[j+1]) { tmp=a[j];

快速排序是不稳定的排序，但是算法复杂度低，平均算法复杂度为：O(nlgn)，最差为O(n^2)。空间复杂度为：O(lgn)#includeint PARTITION(int a[],int i,int j){ int key=a[i]; //记录关键字 while(i<j) { while(i<j && key<=a[j]) //向右扫描 j--; /

希尔排序是不稳定排序，平均算法复杂度和最坏算法复杂度为：O(nlgn)，最好的情况为O(n)；空间复杂度为O(1)；希尔排序是插入排序的一种，且希尔排序的算法复杂度大大低于插入排序，只是由稳定变为不稳定的排序。#includevoid Shell_Insert(int a[],int d,int n){ int i,j,rc; for(i=d;i<n;i++) { i

插入排序是稳定的排序，平均情况和最坏情况的算法复杂度为O(n^2)，最好情况为O(n)；空间复杂度为：O(1)。#includevoid InsertSort(int a[],int n){ int i,j,rc; for(i=1;i<n;i++) { if(a[i-1]>a[i]) { rc=a[i]; j=i; while(j-1>=0 && rc<

选择排序是不稳定排序，平均算法复杂度和最坏算法复杂度为：O(n^2)；空间复杂度为O(1)；稳定性说明：举个例子，序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法#includevoid select_sort(int a[],int n){ int i,j,pos,tmp

把二元查找树转变成排序的双向链表（树） 题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。    10   /  \  6   14 / \  / \4  8 12 16 转换成双向链表4=6=8=10=12=14=16。思路：中序遍历二叉查找树，因此结点按从小到大顺序访问，假设之前访问过的

动态规划并不是一种算法，而是一种解决问题的思路。典型的动态规划问题，如最长公共子序列（LCS），最长单调子序列（LIS）等。动态规划分为四个步骤：1.判断问题是否具有最优子结构这里以LCS为例，X={x1,x2,...,xi}；Y={y1,y2,...,yj}。最长公共子序列Z={z1,z2,...,zk}；①如果xi=yj，那么zk=xi=yj，且Zk-1是序列Xi-1和Yj-1

//节点的数据结构typedef struct node{ int data; node *next;}LinkList;//逆序生成链表L：L为头节点，n为链表长度void CreatList(LinkList *L,int n){ LinkList *p; L=(LinkList *)malloc(sizeof(LinkList)); L->next =NULL;

#include#include#define STACKINCREMENT 10//每次追加栈空间的大小typedef struct{ StackElemType *top;//栈顶指针 StackElemType *base;//栈底指针 int stacksize;//目前为栈分配的空间，以元素为单位}Stack;//栈是否为空bool StackEmpty(Stack

n阶Hanoi塔问题：假设有3个分别叫X,Y,Z的塔，在塔X上插有n个直径大小个不同的圆盘，编号为1,2,3,...,n。要求将这n个圆盘依次移动到Z塔。void Hanoi(int n,char x,char y,char z){ if(n==1) move(x,1,z); //将编号为1的圆盘从x塔搬到z塔 else{ Hanoi(n-1,x,z,y); //将编号为1到

//节点的结构typedef struct node{ int data; node *next;}LinkList;//创建顺序表了链表,n为链表长度LinkList *Creat(int n){ LinkList *Head; LinkList *p,*tail; Head=(LinkList *)malloc(sizeof(LinkList)); if(!Head)

折半查找：适用于顺序序列int BinSearch(int p[],int key){ int low,high,mid; low=1; high=length_p; while(low<=high){ mid=(low+high)/2; if(p[mid]==key) return mid;//查找成功 else if(p[mid]>key) high=

哈夫曼树也称最优二叉树，顾名思义，即所有叶子结点的带权路径长度最短。对数据进行哈夫曼编码，可以大大减少数据传输量。1.设计Huffman Tree的结点结构，即Huffman Node,并创建Huffman Node//huffman节点结构typedef struct _HUFFMAN_NODE{ char str; //需编译的字符 double frequence; //字

//快速排序#includevoid quick_sort(int [],int ,int);int _qsort(int [],int ,int );int main(){ int len,i,low,high; int array[]={49,38,65,97,76,13,27}; len=sizeof(array)/sizeof(array[0]); low=0;

堆排序是不稳定的排序，平均情况和最坏情况的算法复杂度为O(NlgN)，空间复杂度为：O(1)#include#includevoid swap(int &a,int &b){ int tmp; tmp=a; a=b; b=tmp;}void HeapAjust(int a[],int i,int n){ int rc=i; int rs=a[rc]; fo