直接插入排序:
x:需要插入数组的数;
count:数组中现有元素个数;
bz:boolean,为是否向数组末尾插入的标记

{main}
bz:=true;
for i:=1 to count do
  if x<a[i] then //如果是从大到小排列,则应为x>a[i]
  begin
    for j:=count downto i do a[j+1]:=a[j];
    a[i]:=x;
    count:=count+1;
    bz:=false;
    break;
  end;
if bz then
begin
  count:=count+1;
  a[count]:=x;
end;

Floyed算法:(求图中任意两节点的最短路径及长度)
g:array[1..x,1..x] of integer; //储存图的矩阵
a:array[1..x,1..x] of integer; //保存最短路径长度,初始值为maxint
p:array[1..x,1..x] of set of integer; //保存最短路径

{main}
假设有n个节点
for i:=1 to n do
  for j:=1 to n do
  if g[i,j]>0 then
  begin
    a[i,j]:=g[i,j];
    p[i,j]:=[i]+[j];
  end;
for k:=1 to n do //以k为桥梁求从i到j的最短路径
  for i:=1 to n do
    for j:=1 to n do
    begin
      if (i=j) or (i=k) or (j=k) then continue;
      if a[i,k]+a[k,j]<a[i,j] then
      begin
        a[i,j]:=a[i,k]+a[k,j];
        p[i,j]:=p[i,k]+p[k,j];
      end;
    end;

根据二叉树先序和中序还原二叉树:
procedure create(var tree:treetype; pre:string{先序}; mid{中序):string);
var
  ...
begin
  x:=pos(pre[1],mid);
  ltm:=copy(mid,1,x-1); //求左子树中序
  rtm:=copy(mid,x+1,length(mid)-x); //求右子树中序
  ltp:=copy(pre,2,length(ltm)); //求左子树先序
  rtp:=copy(pre,length(ltm)+2,length(rtm)); //求右子树先序
  if length(ltp)>0 then //还原左子树
  begin
    tree[pre[1]].lch:=ltp[1];
    create(tree,ltp,ltm);
  end;
  if length(rtp)>0 then //还原右子树
  begin
    tree[pre[1]].rch:=rtp[1];
    create(tree,rtp,rtm);
  end;
end;

二叉树的遍历:
procedure order(x:integer);
begin
  if x<>0 then
  begin
先序:write(tree[x].data);
     order(tree[x].lch);
     order(tree[x].rch);

中序:order(tree[x].lch);
     write(tree[x].data);
     order(tree[x].rch);

后序:order(tree[x].lch);
     order(tree[x].rch);
     write(tree[x].data);
  end;
end;

树的宽度优先搜索:
procedure widesearch(tree:treetype; var team:teamtype);
var
  ...
begin
  x:=team.data[team.head];
  team.head:=team.head+1;
  访问节点x;
  for i:=1 to tree[x].degree do
  begin
    team.tail:=team.tail+1;
    team.data[team.tail]:=tree[x].child[i];
  end;
  if team.head<=team.tail then widesearch(tree,team);
end.

树的深度优先搜索:
procedure deepsearch(tree:treetype; x:integer);
var
  ...
begin
  访问节点x;
  for i:=1 to tree[x].degree do
    if tree[x].child[i]<>0 then deepsearch(tree,tree[x].child[i]);
end;

Prim算法(求图的最小生成树):
s:集合类型,存放访问过的节点
te:栈,存放最小生成树的边

{init}
s:=[1];
te.top:=0;

{main}
repeat
  min:=maxint;
  for i:=1 to n do
    for j:=1 to n do
      if (i in s) and (not (j in s)) and (graph[i,j]>0) and (graph[i,j]<min) then
      begin
        min:=graph[i,j];
        x:=i;
        y:=j;
      end;
  s:=s+[y];
  push(te,x,y);
until te.top=n-1;

直接选择排序:
for i:=1 to (n-1) do
begin
  k:=i;
  for j:=(i+1) to n do
    if a[j]<a[k] then k:=j; //如果是从大到小排列,则是a[j]>a[k]
  x:=a[i];
  a[i]:=a[k];
  a[k]:=x;
end;

真的好棒啊

顶~~~~~~~