菜鸟一个 自己随便编的，有问题概不负责，随便看看就好
bogosort
#include<iostream>
using namespace std;
void shuffle(int *agrv,int agrc)
{
int i,r,temp;
srand((unsigned)time(0));
for(i=0;i<(agrc-1);i++)
{
r=rand()%(agrc-i);
temp=agrv[i];
agrv[i]=agrv[i+r];
agrv[i+r]=temp;
}
}
void bogosort(int *agrv,int agrc)
{
bool flag=true;
while(1)
{
for(int i=0;i<agrc;i++)
{
if(agrv[i]<agrv[i+1])
{
flag=false;
break;
}
}
if(flag) return;
shuffle(agrv,agrc);
}
}
int main()
{
int arr[10]={4,3,8,6,4,8,2,1,43,7};//如果待排序的数列一开始就是从大到小的则直接就得到结果
bogosort(arr,10);
for(int i=0;i<10;i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
}
BST树
// Example program
#include <iostream>
using namespace std;
typedef struct node //typedef是取别名这句相当于struct node取个别名Node，struct node*取个别名BST
{
int key;
struct node *lChild, *rChild;
}Node, *BST;
bool BSTInsert(Node * &p, int element) //返回值类型是bool
{
if(NULL == p) // 空树
{
p = new Node; p->key = element;
p->lChild = p->rChild = NULL;
return true;
}
if(element == p->key) // BST中不能有相等的值
return false;
if(element < p->key) // 递归
return BSTInsert(p->lChild, element);
return BSTInsert(p->rChild, element); // 递归
}
void createBST(Node * &T, int a[], int n) //int * &p=a,把 int * 看成一个类型，a就是一个整型指针，p 是a的别名.引 用就是对已有变量再起一个名字
{
T = NULL;
int i;
for(i = 0; i < n; i++)
{
BSTInsert(T, a[i]);
}
}
void preOrderTraverse(BST T)
{
if(T)
{
cout << T->key << " ";
preOrderTraverse(T->lChild);
preOrderTraverse(T->rChild);
}
}
void inOrderTraverse(BST T)
{
if(T)
{
inOrderTraverse(T->lChild);
cout << T->key << " ";
inOrderTraverse(T->rChild);
}
}
int main()
{
int a[10] = {4, 5, 2, 1, 0, 9, 3, 7, 6, 8};
int n = 10;
BST T;
createBST(T, a, n);
preOrderTraverse(T);
cout << endl;
inOrderTraverse(T);
cout << endl;
return 0;
}
bubblesort
#include<iostream>
using namespace std;
void print(int *Dataarry,int count)
{
for(int i=0;i<count;i++)
{
cout<<Dataarry[i]<<" ";
}
cout<<endl;
}
void bubblesort(int *Dataarry,int count)
{
int temp,k,l;
bool swap=true;
do
{int j=count-1;
l=count-1;
for(int i=0;i<count-1;i++)
{
if(Dataarry[i]>Dataarry[i+1])
{
temp=Dataarry[i];
Dataarry[i]=Dataarry[i+1];//注意此循环前面都没问题，但是最后一次L的值还是前面J减少后的值虽然int j=count-1初始化了j的值，但是l的值不会初始化只会保留最后一次j赋予给l的值，即while条件永远不会满足产生无限循环---->在没有l=count-1的情况下，有了以后就OK了count和l只是控制循环结束的初始值不一定是count只要大于比较次数的任何数都可以
Dataarry[i+1]=temp;
l=--j;
}
k=i;
cout<<"THE"<<k<<"round:"<<endl;
cout<<j;
print(Dataarry,count);
cout<<"-------------------"<<endl;
}
}
while(l!=(count-1));
}
int main()
{
int data[]={10,8,9,7,4,5};
bubblesort(data,6);
cout<<"the sort result :"<<endl;
print(data,6);
return 0;
}
buublesort-improve
#include<iostream>
using namespace std;
void print(int *Dataarry,int count)
{
for(int i=0;i<count;i++)
{
cout<<Dataarry[i]<<" ";
}
cout<<endl;
}
void bubblesort(int *Dataarry,int count)
{
int temp,k,l;
bool swap;
do
{int j=count-1;
swap=false;
l=count-1;
for(int i=0;i<count-1;i++)
{
if(Dataarry[i]>Dataarry[i+1])
{
temp=Dataarry[i];
Dataarry[i]=Dataarry[i+1];//注意此循环前面都没问题，但是最后一次L的值还是前面J减少后的值虽然int j=count-1初始化了j的值，但是l的值不会初始化只会保留最后一次j赋予给l的值，即while条件永远不会满足产生无限循环---->在没有l=count-1的情况下，有了以后就OK了count和l只是控制循环结束的初始值不一定是count只要大于比较次数的任何数都可以
Dataarry[i+1]=temp;
l=--j;
swap=true;
}
k=i;
cout<<"THE"<<k<<"round:"<<endl;
cout<<j;
print(Dataarry,count);
cout<<"-------------------"<<endl;
}
}
while(swap);//swap在do while循环外面定义在里面初始化赋值
}
int main()
{
int data[]={10,8,9,7,4,5};
bubblesort(data,6);
cout<<"the sort result :"<<endl;
print(data,6);
return 0;
}
cocktailsort
#include<iostream>
using namespace std;
void cocktailsort(int *agrv,int agrc)
{
int begin=-1;
int end=agrc-2;
bool swapped;
int temp;
do
{swapped=false;
begin++;
for(int i=begin;i<=end;i++)
{
if(agrv[i]>agrv[i+1])
{
temp=agrv[i];
agrv[i]=agrv[i+1];
agrv[i+1]=temp;
swapped=true;
}
}
if(!swapped)
break;
swapped=false;
end--;
for(int i=end;i>=begin;i--)
{
if(agrv[i]>agrv[i+1])
{
temp=agrv[i];
agrv[i]=agrv[i+1];
agrv[i+1]=temp;
swapped=true;
}
}
}while(swapped);
}
int main()
{
int x[]={3,6,3,9,78,54,22,67};
cocktailsort(x,8);
for(int i=0;i<8;i++)
cout<<x[i]<<" ";
}
gnomesort
#include<iostream>
#include<time.h>
using namespace std;
void gnomesort(int *agrv,int agrc)
{
int temp;
int pos=1;
while(pos<agrc)
{
if(agrv[pos]>=agrv[pos-1])
{
pos+=1;
}
else
{
temp=agrv[pos];
agrv[pos]=agrv[pos-1];
agrv[pos-1]=temp;
if(pos>1)
{
pos-=1;
}
}
}
}
int main()
{
clock_t begin,end;
begin=clock();//测试时间开始点
int arr[10];
srand((unsigned)time(0));//初始化种子防止每次运行程序都随机一样的数，因为time(0)做参数时刻都在变化
for(int i=0;i<10;i++)
{
arr[i]=rand()%10;//产生随机数
}
cout<<"THE ARRY is"<<endl;
for(int i=0;i<10;i++)
{
cout<<arr[i]<<" ";
}
gnomesort(arr,sizeof(arr)/sizeof(int));
cout<<"THE sorted arry is:";
for(unsigned i=0;i<sizeof(arr)/sizeof(int);i++)
{
cout<<arr[i]<<" ";
}
end=clock();//测试时间截止点
cout<<endl;
cout<<(double(end-begin)/CLOCKS_PER_SEC);
}
heapsort
#include<iostream>
using namespace std;
void siftdown(int *agrv,int agrc1,int agrc2)//把最大值放到root即0的位置，但要注意次函数只能找到整颗二叉数的一条线路中的最大值不能找到整棵的因为只能比较父母和自己的子节点不能比较父母节点和别人的子节点的大小
{
int root,child,swap,temp;
root=agrc1;
while((root*2+1)<agrc2)//保证这个结点的子节点以及以下保持父母节点大于子节点
{
child=root*2+1;
swap=root;
if(agrv[swap]<agrv[child])
{
swap=child;
}
if((child+1)<agrc2&&agrv[swap]<agrv[child+1])
{
swap=child+1;
}
if(swap==root)
return;
else
{
temp=agrv[root];
agrv[root]=agrv[swap];
agrv[swap]=temp;
root=swap;//使while能进行下去
}
}
}
void heapify(int *agrv,int agrc)//找到整棵数的最大值,并且形成一个树（根节点一定大于孩子节点）
{
int start=(agrc-2)/2;
while(start>=0)
{
siftdown(agrv,start,agrc);
start-=1;
}
}
void heapsort(int *agrv,int agrc)
{
int end=agrc-1;//这里一定不能写成end=agrc-1
int temp;
heapify(agrv,agrc);
while(end>0)
{
int j=0;
temp=agrv[0];
agrv[0]=agrv[end];
agrv[end]=temp;
end-=1;
j++;
cout<<"THEV "<<j<<"sort is"<<endl;
for(int i=0;i<agrc;i++)
{
cout<<agrv[i]<< " ";
}
cout<<endl;
siftdown(agrv,0,end);
}
}
int main()
{
int a[20];
srand((unsigned)time(0));
for(unsigned i=0;i<sizeof(a)/sizeof(int);i++)
{
a[i]=rand()%100;
}
cout<<"The arry you want to arry is:"<<endl;
for(int i=0;i<20;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
heapsort(a,20);
cout<<"THE arry that's sorted is:"<<endl;
for(int i=0;i<20;i++)
{
cout<<a[i]<<" ";
}
}
initializelist
#include<iostream>
using namespace std;
struct list
{
int agrc;
struct list *next;
};
int main()
{
struct list *head,*newl;
struct list *flag;//保存head的值，顺序输出用
head=0;//这行初始化地址很重要，不然得不出结果
cout<<"please enter 10 number:"<<endl;
for(int i=0;i<10;i++)
{
newl=(struct list *)malloc(sizeof(struct list));
if(!newl)
{
cout<<"overflow"<<endl;
exit(0);
}
cin>>newl->agrc;
if(newl->agrc<=0)
{
break;
}
newl->next=head;
head=newl;
}
newl=head;
flag=head;
while(newl!=0)//while(newl->next!=0)也行
{
cout<<newl->agrc<<" ";
newl=newl->next;
}
cout<<endl;
//线性表的初始化到这里就结束了，因为输出时顺序是逆序的所以下面的代码让其顺序输出
struct list *reverselist;
newl=flag;
while(newl!=0)
{
reverselist=(struct list*)malloc(sizeof(struct list));
if(!reverselist)
{
cout<<"overflow"<<endl;
exit(0);
}
reverselist->agrc=newl->agrc;
reverselist->next=head;
head=reverselist;
newl=newl->next;
}
while(reverselist!=flag)//这里不能是0，不然会重新输出一遍逆序
{
cout<<reverselist->agrc<<" ";
reverselist=reverselist->next;
}
return 0;
}
insertionsort
#include<iostream>
using namespace std;
void insertionsort(int *agrv,int agrc)
{
int i,j,temp;
for(i=1;i<agrc;i++)
{
j=i;
while(j>0&&agrv[j-1]>agrv[j])
{
temp=agrv[j];
agrv[j]=agrv[j-1];
agrv[j-1]=temp;
j-=1;
}
}
}
int main()
{
int a[20];
srand((unsigned)time(0));
for(int i=0;i<20;i++)
{
a[i]=rand()%100;
}
cout<<"the arry you wan to sort is:"<<endl;
for(int i=0;i<20;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
insertionsort(a,20);
cout<<"THe sorted arry is:"<<endl;
for(int i=0;i<20;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
//交换的方法二
// Example program
#include<iostream>
using namespace std;
void insertionsort(int *agrv,int agrc)
{
int x,i,j;
for(i=1;i<agrc;i++)
{
j=i;
x=agrv[i];
while(j>0&&agrv[j-1]>agrv[j])
{
agrv[j]=agrv[j-1];
agrv[j-1]=x;
j-=1;
}
}
}
int main()
{
int a[20];
srand((unsigned)time(0));
for(int i=0;i<20;i++)
{
a[i]=rand()%100;
}
cout<<"the arry you wan to sort is:"<<endl;
for(int i=0;i<20;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
insertionsort(a,20);
cout<<"THe sorted arry is:"<<endl;
for(int i=0;i<20;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
listsort运行结果与预期不符1 （求大神告知什么问题）
// Example program
#include<iostream>
using namespace std;
struct list
{
int agrc;
struct list *next;
};
int main()
{
struct list *head,*newl,*head1;
struct list *flag,*change1,*change2;//保存head的值，顺序输出用
head=0;//这行初始化地址很重要，不然得不出结果
cout<<"please enter 10 number:"<<endl;
for(int i=0;i<10;i++)
{
newl=(struct list *)malloc(sizeof(struct list));
cin>>newl->agrc;
newl->next=head;
head=newl;
}
newl=head;
flag=head;
while(newl!=0)//while(newl->next!=0)也行
{
cout<<newl->agrc<<" ";
newl=newl->next;
}
cout<<endl;
//线性表的初始化到这里就结束了，因为输出时顺序是逆序的所以下面的代码让其顺序输出
struct list *reverselist;
head1=0;
change2=head1;
change1=head1;
newl=flag;
bool condi;
while(flag!=0)
{
condi=true;
cout<<"wee"<<endl;
reverselist=(struct list*)malloc(sizeof(struct list));
reverselist->agrc=flag->agrc;
while(reverselist->agrc<=head1->agrc&&head1!=0)
{
change1=head1;
head1=head1->next;
condi=false;
}
if(!condi)
{
change1->next=reverselist;
reverselist->next=head1;
head1=change2;
}
else
{
reverselist->next=head1;
head1=reverselist;
change2=head1;
}
flag=flag->next;
}
reverselist=head1;
while(reverselist!=flag)
{
cout<<reverselist->agrc<<" ";
reverselist=reverselist->next;
}
return 0;
}
oddevensort
#include<iostream>
using namespace std; //在for里面定义的i不能在for外面使用，?&1==1得到的是奇数,&与运算
void oddevensort(int *agrv,int agrc)
{
int temp;
for(int i=0;i<agrc;i++)
{
if(i&1)//if是奇数&是与前面都是与0与所以肯定是0就看最后一位，最后一位是1就是奇数
{
for(int j=2;j<agrc;j+=2)
{
if(agrv[j]<agrv[j-1])//这里是如果这里换成大于号自己想想结果,不过这里换成大号只要下面也换成大号的话就没问题只是升序和降序的区别
{
temp=agrv[j];
agrv[j]=agrv[j-1];
agrv[j-1]=temp;
}
}
}
else
{
for(int j=1;j<agrc;j+=2)
{
if(agrv[j]<agrv[j-1])//如果比较agrv[i]和agrv[i+1]则注意别越界for循环(j<agrv-1)
{
temp=agrv[j];
agrv[j]=agrv[j-1];
agrv[j-1]=temp;
}
}
}
}
}
int main()
{
int arr[]={34,32,52,7,9,3,12,4};
oddevensort(arr,sizeof(arr)/sizeof(int));
for(int i=0;i<8;i++)
cout<<arr[i]<<" ";
}
quicksort
// Example program
#include<iostream>
using namespace std;
void quicksort(int *agrv,int lo,int hi)
{
int partition(int*,int,int);
int p;
if(lo<hi)
{
p=partition(agrv,lo,hi);
quicksort(agrv,lo,p-1);
quicksort(agrv,p+1,hi);
}
}
int partition(int *agrv,int lo,int hi)
{
int pivot=agrv[hi];
int i=lo;
int temp;
for(int j=lo;j<hi;j++)
{
if(agrv[j]<pivot)
{
temp=agrv[i];
agrv[i]=agrv[j];
agrv[j]=temp;
i+=1;
}
cout<<"THETIME of arry "<<j+1<<" is "<<endl;
for(int i=0;i<(hi-lo+1);i++)
{
cout<<agrv[i]<<" ";
}
cout<<endl;
}
{
temp=agrv[i];
agrv[i]=agrv[hi];
agrv[hi]=temp;
}
return i;
}
int main()
{
int arr[10];
srand((unsigned)time(0));
for(int i=0;i<10;i++)
{
arr[i]=rand()%10;
}
cout<<"THE arr we sorted is:"<<endl;
for(int i=0;i<10;i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
quicksort(arr,0,9);
cout<<"THE sorted arry is:"<<endl;
for(int i=0;i<10;i++)
{
cout<<arr[i]<<" ";
}
return 0;
}
quicksortpattern2
// Example program
#include<iostream>
using namespace std;
void quicksort(int *agrv,int agrc1,int agrc2)
{
if(agrc1<agrc2)
{
int pivot=agrv[agrc1];//从这里开始的3行不能放到if循环之外
int i=agrc1-1;
int j=agrc2+1;
int temp;
static int k=0;//为了不被初始化能显示每一次的排序
while(i<j)
{
do
{
j=j-1;
}
while(agrv[j]>pivot);//while 后面记得用冒号
do
{
i=i+1;
}
while(agrv[i]<pivot);//while后面记得用冒号
if(i<j)
{
temp=agrv[i];
agrv[i]=agrv[j];
agrv[j]=temp;
k+=1;
cout<<"THE nuber of sort "<<k<<" is "<<endl;
for(int i=0;i<=agrc2;i++)
{
cout<<agrv[i]<<" ";//为了能显示每一次的排序所以要放在交换的里面
}
cout<<endl;
}
}
cout<<endl;
quicksort(agrv,agrc1,j);
quicksort(agrv,j+1,agrc2);//这里不能是i因为会是无限循环 。也不能是j,j也不能是j-1,j此时无限循环但是不执行任何语句因为初始化时pivot=agrv[agrc1]所以while(agrv[j]>pivot)一定会在某个点满足最差是在agrv[agrc1]，但i不同i时每次递增的i=i+1，所以一旦错过了agrc1可能一直满足while(agrv[i]<pivot)，溢出以后agrv[i]的值是0一直比pivot小,i的值可能溢出J的值不会当时j,j的时候若是碰到某次不用排序的时刻即j=0，则初始条件无法改变一直无限循环0，0、、0,agrv[agrc2]2个数组
}
}
int main()
{
int arr[10];
srand((unsigned)time(0));
for(unsigned i=0;i<sizeof(arr)/sizeof(int);i++)
{
arr[i]=rand()%10;
}
cout<<"The arr you want to sort is"<<endl;
for(unsigned i=0;i<sizeof(arr)/sizeof(int);i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
quicksort(arr,0,9);
cout<<"The sorted arry is:"<<endl;
for(int i=0;i<9;i++)
cout<<arr[i]<<" ";
}
shellsort
#include<iostream>
using namespace std;
void shellsort(int agrc,int *agrv)
{
int gap=agrc/2;
int temp;
int k=1;
for(;gap>0;gap=gap/2)//gap等于0会产生无限循环
{
int j;
for(int i=gap-1;i<agrc;i++)
{
temp=agrv[i];
for(j=i;j>=gap&&agrv[j-gap]>temp;j-=gap)//这里j>=gap不能写成j>gap不然第一个元素不能被排序
{
agrv[j]=agrv[j-gap];
}
agrv[j]=temp;
cout<<"k="<<k<<" "<<endl;
for(int i=0;i<agrc;i++)
{
cout<<agrv[i]<<" ";
}
k++;
cout<<endl;
}
cout<<endl;
}
}
int main()
{
int arr[20];
srand((unsigned)time(0));
for(unsigned i=0;i<sizeof(arr)/sizeof(int);i++)
{
arr[i]=rand()%100;
}
cout<<"The random number you get are:"<<endl;
for(unsigned i=0;i<sizeof(arr)/sizeof(int);i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
shellsort(20,arr);
cout<<"the result of shellsort is:"<<endl;
for(unsigned i=0;i<sizeof(arr)/sizeof(int);i++)
{
cout<<arr[i]<<" ";
}
}
slectionsort
// Example program
#include<iostream>
using namespace std;
void selectsort(int *agrv,int agrc)
{
int j,temp,min;
for(int i=0;i<agrc-1;i++)
{
min=i;
for(j=i+1;j<agrc;j++)
{
if(agrv[j]<agrv[min])
{
min=j;
}
}
if(min!=i)
{
temp=agrv[i];
agrv[i]=agrv[min];
agrv[min]=temp;
}
}
}
int main()
{
int a[10];
srand((unsigned)time(0));
for(int i=0;i<10;i++)
{
a[i]=rand()%10;
}
cout<<"the arry you want to sort is:"<<endl;
for(int i=0;i<10;i++)
{
cout<<a[i]<<" ";
}
selectsort(a,10);
cout<<endl;
cout<<"the sorted arry is:"<<endl;
for(int i=0;i<10;i++)
{
cout<<a[i]<<" ";
}
}
stoogesort
#include<iostream>
using namespace std;
void stoogesort(int *agrv,int agrc1,int agrc2)
{
int temp;
int t;
if(agrv[agrc1]<agrv[agrc2])
{
temp=agrv[agrc1];
agrv[agrc1]=agrv[agrc2];
agrv[agrc2]=temp;
}
if((agrc2-agrc1+1)>2)
{
t=(agrc2-agrc1+1)/3;
stoogesort(agrv,agrc1,agrc2-t);
stoogesort(agrv,agrc1+t,agrc2);
stoogesort(agrv,agrc1,agrc2-t);
}
}
int main()
{
int arr[10];
srand((unsigned)time(0));
cout<<"the arry you want to sort is:"<<endl;
for(int i=0;i<10;i++)
{
arr[i]=rand()%10;
}
for(int i=0;i<10;i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
stoogesort(arr,0,9);
for(int i=0;i<10;i++)
{
cout<<arr[i]<<" ";
}
}
与预期不符有序线性表2（求大神告知原因)
// Example program
#include<iostream>
using namespace std;
struct list
{
int agrc;
struct list *next;
};
int main()
{
struct list *head,*newl;//保存head的值，顺序输出用
head=0;//这行初始化地址很重要，不然得不出结果
cout<<"please enter 10 number:"<<endl;
for(int i=0;i<10;i++)
{
newl=(struct list *)malloc(sizeof(struct list));
cin>>newl->agrc;
newl->next=head;
head=newl;
}
struct list *head1=0;
while(head!=0)
{
struct list *change1=head;
cout<<"wee"<<endl;
head=head->next;
if(head1==0||change1->agrc<head1->agrc)
{
change1->next=head1;
head1=change1;
}
else
{
struct list *change2;
change2=head1;
while(change2!=0)
{
if(change2->next==0||change2->next->agrc<change1->agrc)
{
change1->next=change2->next;
change2->next=change1;
}
else
change2=change2->next;
}
}
}
while(head1!=0)//while(newl->next!=0)也行
{
cout<<head1->agrc<<" ";
head1=head1->next;
}
return 0;
}
判断栈是向下延伸的
// Example program
#include<stdio.h>
static int stack_dir;
static void find_stack_direction (void) {
static char *addr = NULL; /* address of first
`dummy', once known */
char dummy; /* to get stack address */
if (addr == NULL)
{ /* initial entry */
addr = &dummy;
find_stack_direction (); /* recurse once */
}
else /* second entry */
if (&dummy > addr)
stack_dir = 1; /* stack grew upward */
else
stack_dir = -1; /* stack grew downward */
}
int main(void)
{
find_stack_direction();
if(stack_dir==1)
puts("stack grew upward");
else
puts("stack grew downward");
return 0;
}
415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
