各种基本算法

//有些循环体是总0开始,有些是1开始,记都记不住,索性都写成从0开始
//这也说明了我没有深刻理解算法
//唉,插入排序和冒泡这两个最基本的排序都要看了之后才会写
//这样的基础,哪个好公司会要我呢?
//天天把精力花在了奇技淫巧上面,对于基础,反而不重视
//以下两个SWAP都有问题,都不能SWAP(x,x);
#define SWAP(x,y) {if(x!=y){(x)=(x)+(y);(y)=(x)-(y);(x)=(x)-(y);}}
//#define SWAP(x,y) {x^=y^=x^=y;}
void insert_sort(int A[],int n)
{
for(int i=0;i<n;i++)
for(int j=i;j>0&&A[j]<A[j-1];j--)
{
SWAP(A[j],A[j-1]);
}
print();
}
void buble_sort(int A[],int n)
{
for(int i=0;i<n;i++)
for(int j=n-1;j>i;j--)
{
if(A[j]<A[j-1])
SWAP(A[j],A[j-1]);
}
}
int bsearch(int a[],int n,int K)
{
int low=0,high=n-1,mid=0;
while(low<=high) {
mid=low+(high-low)/2;
if(K>a[mid])low=mid+1;
if(K<a[mid])high=mid-1;
if(K==a[mid])return mid;
}
return -1;
}
void select_sort(int A[],int n)
{
int lowest,j;
for(int i=0;i<n;i++)
{
for(j=i,lowest=i;j<n;j++)
{
if(A[lowest]>A[j])
lowest=j;
}
SWAP(A[lowest],A[i]);
print();
}
}
//shell sort
void shellsort(int v[], int n)
{
int gap, i, j;
for (gap = n / 2; gap > 0; gap /= 2)
for (i = gap; i < n; i++)
for (j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap)
{
SWAP(v[j],v[j+gap]);
}
}
void QuickSort(int *pData,int left,int right)
{
int i=left,j=right,middle=0,iTemp=0;
middle=pData[(left+right)/2];//求中间值
//middle=pData[(rand()%(right-left+1))+left]; //生成大于等于left小于等于right的随机数
do
{
while((pData[i]<middle)&&(i<right))//从左扫描大于中值的数
i++;
while((pData[j]>middle) && (j>left))//从右扫描小于中值的数
j--;
//找到了一对值,交换
if(i<=j)
{
SWAP(pData[i],pData[j]);
i++;
j--;
}
}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值(left<j)，递归左半边
if(left<j)
{
QuickSort(pData,left,j);
}
//当右边部分有值(right>i)，递归右半边
if(right>i)
{
QuickSort(pData,i,right);
}
}
void merge_sort(int A[],int * temp,int left,int right)
{
int mid=(left+right)/2;
if(left==right)return;
merge_sort(A,temp,left,mid);
merge_sort(A,temp,mid+1,right);
for(int i=left;i<=right;i++)
temp[i]=A[i];
int i1=left,i2=mid+1;
for(int curr=left;curr<=right;curr++)
{
if(i1==mid+1)//i1到底了
A[curr]=temp[i2++];
else if(i2>right)//i2到底了
A[curr]=temp[i1++];
else if(temp[i1]<temp[i2])
A[curr]=temp[i1++];
else
A[curr]=temp[i2++];
}
}
//图:最短路径算法:
//distance 为源点到所有点的最短距离
//大致思路为:
//假如源点为B,那么首先先找到距离离B最近的那个点X,
//然后以X为基础,更新X附近的点离B的距离
//然后继续寻找除了X点意外的离B最近的那个点
//以此往复,更新所有的点与B的距离
//结果就是到B的最短距离
#define GRAPH_SIZE 10
int adjacency[GRAPH_SIZE][GRAPH_SIZE];
#define INFINiTY 1000
void Dijkstra(int source,int distance[])
{
int v,w;
bool found[GRAPH_SIZE];
for(v=0;v<GRAPH_SIZE;v++)
{
found[v]=false;
distance[v]=adjacency[source][v];
}
found[source]=true;
distance[source]=0;
for(int i=0;i<GRAPH_SIZE;i++)
{
int min=INFINiTY;
for(w=0;w<GRAPH_SIZE;w++)
{
if(!found[w])
if(distance[w]<min)
{
v=w;
min=distance[w];
}
}
found[v]=true;
for(w=0;w<GRAPH_SIZE;w++)
{
if(!found[w])
if(min+adjacency[v][w]<distance[w])
distance[w]=min+adjacency[v][w];
}
}
}

int parent(int);
int left(int);
int right(int);
void Max_Heapify(int [], int, int);
void Build_Max_Heap(int [], int);
void print(int [], int);
void HeapSort(int [], int);
 
/*父結點*/
int parent(int i)
{
    return (int)floor((i - 1) / 2);
}
 
/*左子結點*/
int left(int i)
{
    return (2 * i + 1);
}
 
/*右子結點*/
int right(int i)
{
    return (2 * i + 2);
}
 
/*單一子結點最大堆積樹調整*/
void Max_Heapify(int A[], int i, int heap_size)
{
    int l = left(i);
    int r = right(i);
    int largest;
    int temp;
    if(l < heap_size && A[l] > A[i])
    {
        largest = l;
    }
    else
    {
        largest = i;
    }
    if(r < heap_size && A[r] > A[largest])
    {
        largest = r;
    }
    if(largest != i)
    {
        temp = A[i];
        A[i] = A[largest];
        A[largest] = temp;
        Max_Heapify(A, largest, heap_size);
    }
}
 
/*建立最大堆積樹*/
void Build_Max_Heap(int A[]，int heap_size)
{
    for(int i = (heap_size-2)/2; i >= 0; i--)
    {
        Max_Heapify(A, i, heap_size);
    }
}
 
/*印出樹狀結構*/
void print(int A[]， int heap_size)
{
    for(int i = 0; i < heap_size;i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
}
 
/*堆積排序程序碼*/
void HeapSort(int A[], int heap_size)
{
    Build_Max_Heap(A, heap_size);
    int temp;
    for(int i = heap_size - 1; i >= 0; i--)
    {
        temp = A[0];
        A[0] = A[i];
        A[i] = temp;
        Max_Heapify(A, 0, i); // 调整未排序的堆
    }
    print(A, heap_size);
}
 
/*輸入資料並做堆積排序*/
int main(int argc, char* argv[])
{
    const int heap_size = 13;
    int A[] = {19, 1, 10, 14, 16, 4, 7, 9, 3, 2, 8, 5, 11};
    HeapSort(A, heap_size);
    system("pause");
    return 0;
}