各种排序(数据结构复习之内部排序算法总结)

1.三种选择排序（简单选择排序，树形选择排序，堆排序）

#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;typedef struct
{int a[100];int len;void outList(){for(int i=1; i<=len; ++i)cout<<a[i]<<" ";cout<<endl;}
}list;
list L;int smaller(int a, int b)
{return a>b?b:a;
}
/**********************************************************************************/
void sample_selection_sort()//简单选择排序 
{int i, j, k;for(i=1; i<=L.len; i++){k=i;for(j=i+1; j<=L.len; j++)if(L.a[k]>L.a[j])k=j;if(k!=i){L.a[i]^=L.a[k];L.a[k]^=L.a[i];L.a[i]^=L.a[k];}}
} 
/**********************************************************************************/
int tree[400];
void tree_choose_sort(int ld, int rd, int p)//树形选择排序，和线段树差不多 
{if(rd==ld)tree[p]=L.a[ld];else{int mid=(ld+rd)/2;tree_choose_sort(ld, mid, p<<1);tree_choose_sort(mid+1, rd, p<<1|1);tree[p]=smaller(tree[p<<1], tree[p<<1|1]);}
}void update_tree(int ld, int rd, int p, int key)//树形选择排序
{if(rd==ld){if(key==tree[p])tree[p]=INF;} else{int mid=(ld+rd)/2;if(key==tree[p<<1]) update_tree(ld, mid, p<<1, key);elseupdate_tree(mid+1, rd, p<<1|1, key);tree[p]=smaller(tree[p<<1], tree[p<<1|1]);}
}
/**********************************************************************************/typedef struct tree//树形选择排序 
{int d;struct tree *lchild;struct tree *rchild;
}*TREE;
void build_tree(TREE &T, int ld, int rd)//树形选择排序
{if(ld==rd){ T->lchild=T->rchild=NULL;T->d=L.a[ld];}else{int mid=(rd+ld)/2;T=(TREE)malloc(sizeof(tree));T->lchild=(TREE)malloc(sizeof(tree));T->rchild=(TREE)malloc(sizeof(tree));build_tree(T->lchild, ld, mid);build_tree(T->rchild, mid+1, rd);T->d=smaller(T->lchild->d, T->rchild->d);}
}void Update_tree(TREE &T, int key)//树形选择排序
{if(T){if(!T->lchild && !T->rchild){if(T->d==key)T->d=INF;}else{if(key==T->lchild->d)Update_tree(T->lchild, key);else if(key==T->rchild->d)Update_tree(T->rchild, key);T->d=smaller(T->lchild->d, T->rchild->d);}}
}
/**********************************************************************************/void heapAdjust(int ld, int rd){//堆排序, 排序区间[ld，rd] int rc = L.a[ld];int cur = ld;for(int p = ld*2; p<=rd; p=p*2){if(p<rd && L.a[p] > L.a[p+1]) ++p;//取左右子树的最小值if(rc < L.a[p]) break;//如果父节点的值比左右子树的值都小，那么已经调整好了，已经是小堆顶了L.a[cur] = L.a[p];//否则交换父节点和左右子树最小的子树的值，父节点的值存在rc中，所以只要将最小子树的值赋给父节点就好 cur = p;}L.a[cur] = rc;
}/**********************************************************************************/int main() {int i;scanf("%d", &L.len);for(i=1; i<=L.len; i++)scanf("%d", &L.a[i]);//selection_sort();//选择排序 //   tree_choose_sort(1, L.len, 1);//树形选择排序 
//   
//   int n=L.len;
//   while(n--)
//    {
//       printf("%d ", tree[1]);
//       update_tree(1, L.len, 1, tree[1]);
//    }//   TREE T;//树形选择排序 
//   build_tree(T, 1, L.len);
//   int n=L.len;
//   while(n--)
//    {
//       printf("%d ", T->d);
//       Update_tree(T, T->d);
//    }for(int i=L.len/2; i>=1; --i)//将整个区间调整成小堆顶 
        heapAdjust(i, L.len);for(int i=1; i<=L.len; ++i) {cout<<L.a[1]<<" "; L.a[1] = L.a[L.len-i+1];//将最后一个元素赋给第一个元素 heapAdjust(1, L.len-i);//重新调整堆 
    }cout<<endl;return 0;
}

 2.冒泡排序

#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;typedef struct
{int a[100];int len;void outList(){for(int i=1; i<=len; ++i)cout<<a[i]<<" ";cout<<endl;}
}list;
list L;void bubble_sort()
{int i, j, change=1;for(j=L.len; change && j>=1; j--){change=0;for(i=1; i<j; i++)if(L.a[i]>L.a[i+1]){L.a[i]^=L.a[i+1];L.a[i+1]^=L.a[i];L.a[i]^=L.a[i+1];change=1;}}
}int main() {int i;scanf("%d", &L.len);for(i=1; i<=L.len; i++)scanf("%d", &L.a[i]);bubble_sort(); return 0;
}

3.快速排序(有两种的分割方法，第二种分割方法效率更高一些)

#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;typedef struct
{int a[100];int len;void outList(){for(int i=1; i<=len; ++i)cout<<a[i]<<" ";cout<<endl;}
}list;
list L;int partition(int low, int high)//将数据元素划分为左边都小于枢轴，右边元素都大于枢轴 
{//采用三者取中的方法选择枢轴 if((L.a[high]-L.a[low]) * (L.a[high]-L.a[(low+high)/2]) < 0)swap(L.a[low], L.a[high]);else if((L.a[(low+high)/2]-L.a[low]) *(L.a[(low+high)/2]-L.a[high]) < 0)swap(L.a[low], L.a[(low+high)/2]);int pivotkey=L.a[low];// 枢轴关键字while(low<high){while(low<high && L.a[high]>=pivotkey)high--;L.a[low]=L.a[high];while(low<high && L.a[low]<=pivotkey)low++;L.a[high]=L.a[low];}L.a[low]=pivotkey; return low;
}

int partitionTwo(int ld, int rd){
　　int mid = (ld+rd)>>1;
　　if((a[mid]-a[ld]) * (a[mid]-a[rd]) < 0)
　　　　swap(a[mid], a[ld]);
　　else if((a[rd]- a[ld]) * (a[rd]-a[mid]) < 0)
　　　　swap(a[rd], a[ld]);

　　int i=ld;//使得表a[ld.....i] 中的所有的元素都是小于pivot的元素，初始表为空， a[ld]表示枢轴
　　int pivot = a[ld];
　　for(int j=ld+1; j<=rd; ++j)
　　　　if(a[j] < pivot)
　　　　　　swap(a[++i], a[j]);
　　swap(a[i], a[ld]);
　　return i;
}

void Qsort(int low, int high)//快速排序 
{if(low<high){int p=partition(low, high);Qsort(low, p-1);Qsort(p+1, high);}
}int main() {int i;scanf("%d", &L.len);for(i=1; i<=L.len; i++)scanf("%d", &L.a[i]);Qsort(1, L.len); L.outList();return 0;
}

 

4.归并排序

#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;typedef struct
{int a[100];int len;void outList(){for(int i=1; i<=len; ++i)cout<<a[i]<<" ";cout<<endl;}
}list;
list L;void Merge(int lr, int rr)//归并排序 
{int atemp[100], mid=(lr+rr)/2;//atemp[]存放两个有序表合并后的结果int i, j, k;for(i=lr, j=mid+1, k=0; i<=mid && j<=rr; )//将两个有序表的合并代码 
     {if(L.a[i]<=L.a[j])atemp[k++]=L.a[i++];elseatemp[k++]=L.a[j++];     }if(i>mid)for(k; j<=rr; j++)atemp[k++]=L.a[j];if(j>rr)for(k; i<=mid; i++)atemp[k++]=L.a[i]; memcpy(L.a+lr, atemp, sizeof(int)*k);//将两段儿有序表合并后的结果 
}                                     //复制到原来对应的位置上 void Msort(int ld, int rd)
{if(ld<rd){int mid=(ld+rd)/2;Msort(ld, mid);Msort(mid+1, rd);Merge(ld, rd);//回溯法合并有序 序列 
     }
}int main() {int i;scanf("%d", &L.len);for(i=1; i<=L.len; i++)scanf("%d", &L.a[i]);Msort(1, L.len); L.outList();return 0;
}

5.插入排序

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio> 
using namespace std;
const int INF=0X3f3f3f3f;
typedef struct
{int a[100];int len;void outList(){for(int i=1; i<=len; ++i){cout<<a[i]<<" ";}cout<<endl;}
}list;
list L;/*********************************************************************/ 
void direct_insertion_sort()//直接插入排序 
{int i, j;for(i=2; i<=L.len; i++){L.a[0]=L.a[i];for(j=i-1; L.a[0]<L.a[j]; j--)L.a[j+1]=L.a[j];L.a[j+1]=L.a[0];}
}/*********************************************************************/ void benary_insertion_sort1()//折半插入排序 
{int i, j, left, right, mid;for(i=2; i<=L.len; i++){left=1;right=i-1;L.a[0]=L.a[i];while(left<=right){mid=(left+right)/2;if(L.a[mid]<=L.a[0])left=mid+1;elseright=mid-1;}for(j=i-1; j>=left; j--)L.a[j+1]=L.a[j];L.a[j+1]=L.a[0];}
} /*********************************************************************/ void benary_insertion_sort2(){//折半插入排序 for(int i=2; i<=L.len; ++i){L.a[0] = L.a[i];int k = upper_bound(L.a+1, L.a+i, L.a[0]) - L.a;//返回最后一个大于key的位置 for(int j=i; j>k; --j)L.a[j] = L.a[j-1];L.a[k] = L.a[0];}
}/*********************************************************************/ 
void twoWay_insertion_sort()//二路插入排序 
{int *d=(int *)malloc(sizeof(int)*L.len);int first, final, i, j;first=final=0;d[0]=L.a[1];for(i=2; i<=L.len; i++){if(L.a[i]>=d[final])//直接添加在尾部 d[++final]=L.a[i];else if(L.a[i]<=d[first])//直接添加在头部 d[first=(first-1+L.len)%L.len]=L.a[i];else//在头部和尾部中间
          {for(j=final++; d[j]>=L.a[i]; j=(j-1+L.len)%L.len)d[(j+1)%L.len]=d[j];d[(j+1)%L.len]=L.a[i];}}for(i=first, j=1; i!=final; i=(i+1)%L.len, j++)L.a[j]=d[i];
 　　L.a[j] = d[i];
}/*********************************************************************/ 
void shell_insertion_sort(int d)
{int i, j;for(i=d+1; i<=L.len; i++){if(L.a[i]<L.a[i-d])//需要将L.a[i]插入有序增量字表 
           {L.a[0]=L.a[i];for(j=i-d; j>=1 && L.a[0]<=L.a[j]; j-=d)L.a[j+d]=L.a[j];L.a[j+d]=L.a[0];}}
}void shellsort()//希尔排序 
{int dk[]={5, 3, 1};//设置子序列的增量 for(int i=0; i<3; i++)shell_insertion_sort(dk[i]);
}/*********************************************************************/ typedef struct xxx{int head;//头结点 int a[100];int next[100];//记录下一个元素的位置 int len;xxx(){head = 1;memset(next, 0, sizeof(next));}void outList(){for(int i=1; i<=len; ++i){cout<<a[i]<<" ";}cout<<endl;}
}Listx; Listx Lx;void table_insertion_sort(){//表插入排序，相当于静态链表 for(int i=2; i<=Lx.len; ++i){int pre, p;for(p=Lx.head; p && Lx.a[p]<Lx.a[i]; pre=p, p=Lx.next[p]);if(p==0){Lx.next[pre] = i;} else if(p==Lx.head){Lx.next[i] = Lx.head;Lx.head = i;} else {Lx.next[pre] = i;Lx.next[i] = p;} }//输出for(int i=Lx.head; i; i = Lx.next[i]) cout<<Lx.a[i]<<" ";cout<<endl;
}void arrang_table() {int p = Lx.head, q;for(int i=1; i<Lx.len; ++i){while(p < i) p = Lx.next[p];//第i个记录在表中的位置不应该小于 i，如果小于i，说明该元素已经被交换位置了，可以通过next继续寻找 q = Lx.next[p];//指向下一个节点 if(p!=i){//第p个元素应该在第i个位置 
            swap(Lx.a[i], Lx.a[p]);swap(Lx.next[i], Lx.next[p]);Lx.next[i] = p;//该元素之前的位置 p，指向被移走的记录，使得以后可由while循环找回 
        }p = q;}for(int i=1; i<=Lx.len; ++i) cout<<Lx.a[i]<<" ";cout<<endl;
}/*********************************************************************/ int main()
{int i;scanf("%d", &Lx.len);for(i=1; i<=Lx.len; i++)scanf("%d", &Lx.a[i]);
//    benary_insertion_sort2();
//    L.outList();
    table_insertion_sort();arrang_table();return 0;
}/*
8
49 38 6 5 97 76 13 27 49
*/

 6.基数排序(LSD and MSD)

#include<iostream> 
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<queue> 
#define N 1000
using namespace std;/*题目：对基数排序的练习, 它是一种很特别的方法，它不是基于比较进行排序的，而是采用多关键字排序思想，借助"分配" 和 "收集" 两种操作对单逻辑关键字进行排序， 分为最高位优先MSD排序和最低为优LSD先排序 
*/int radix[]={1, 10, 100, 1000};//每个数字的位数最多是3位int cnt[10];
int a[N], bucket[N];
int n; 
int k;//记录数字中位数最多的 /*
（1）LSD最低位优先法实现最低位优先法首先依据最低位关键码Kd对所有对象进行一趟排序，再依据次低位关键码Kd-1对上一趟排序的结果再排序，依次重复，直到依据关键码K1最后一趟排序完成，就可以得到一个有序的序列。使用这种排序方法对每一个关键码进行排序时，不需要再分组，而是整个对象组。
*/
void LSD_radixSort(){for(int i=1; i<=k; ++i){memset(cnt, 0, sizeof(cnt));//统计各个桶中所盛数据个数, 关键字相同的数字放入到同一个桶中 for(int j=1; j<=n; ++j)++cnt[a[j]%radix[i]/radix[i-1]];//cnt[i]表示第i个桶的右边界索引for(int j=1; j<10; ++j)cnt[j] += cnt[j-1];//把数据依次装入桶(注意装入时候的分配技巧)for(int j=n; j>=1; --j){//这里要从右向左扫描，保证排序稳定性 int x = a[j]%radix[i]/radix[i-1]; //求出关键码的第k位的数字， 也就是第x个桶的编号， 例如：576的第3位是5 bucket[cnt[x]] = a[j];//放入对应的桶中，cnt[x]是第x个桶的右边界索引 --cnt[x];//对应桶的装入数据索引减一  
        }memcpy(a, bucket, sizeof(int)*(n+1));}
}/*（2）MSD最高位优先法实现最高位优先法通常是一个递归的过程：<1>先根据最高位关键码K1排序，得到若干对象组，对象组中每个对象都有相同关键码K1。<2>再分别对每组中对象根据关键码K2进行排序，按K2值的不同，再分成若干个更小的子组，每个子组中的对象具有相同的K1和K2值。<3>依此重复，直到对关键码Kd完成排序为止。<4> 最后，把所有子组中的对象依次连接起来，就得到一个有序的对象序列。
*/void MSD_radixSort(int ld, int rd, int radixI){//[ld, rd]是a数组的待排序的区间，radixI是当前这段数组每个数字的基数 int cnt[11];//必须每个栈中都定义 memset(cnt, 0, sizeof(cnt));//统计各个桶中所盛数据个数, 关键字相同的数字放入到同一个桶中 for(int j=ld; j<=rd; ++j)++cnt[a[j]%radix[radixI]/radix[radixI-1]];//cnt[i]表示第i个桶的右边界索引for(int j=1; j<=10; ++j)cnt[j] += cnt[j-1];//把数据依次装入桶(注意装入时候的分配技巧)for(int j=rd; j>=ld; --j){//这里要从右向左扫描，保证排序稳定性 int x = a[j]%radix[radixI]/radix[radixI-1]; //求出关键码的第k位的数字， 也就是第x个桶的编号， 例如：576的第3位是5 bucket[cnt[x]] = a[j];//放入对应的桶中，cnt[x]是第x个桶的右边界索引 --cnt[x];//对应桶的装入数据索引减一  
    }for(int i=ld, j=1; i<=rd; ++i, ++j)//重排区间[ld, rd], a数组区间[ld,rd]对应bucket数组区间[1, rd-ld+1] a[i] = bucket[j];for(int i=0; i<10; ++i){//对各个桶中的数据在进行下一个关键字的排序 int ldd = ld + cnt[i];int rdd = ld + cnt[i+1] - 1; //获得子桶的子区间[ldd, rdd] if(ldd < rdd && radixI>1)MSD_radixSort(ldd, rdd, radixI-1);}
}int main(){cin>>n;k = 0; for(int i=1; i<=n; ++i){cin>>a[i];k = max(k, (int)log10(a[i])+1);}
//    LSD_radixSort();
//    for(int i=1; i<=n; ++i) 
//        cout<<a[i]<<" " ;
//    cout<<endl;
MSD_radixSort(1, n, k);for(int i=1; i<=n; ++i) cout<<a[i]<<" " ;cout<<endl;return 0;
}
/*
7
329 457 657 839 436 720 355
*/

转载于:https://www.cnblogs.com/hujunzheng/p/4676810.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/531449.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

（八）C语言之结构

（八）C语言之结构

今天来说一下C语言里的结构体(struct)、共用体(l联合体)union、枚举。 &#xff08;一&#xff09;结构体&#xff1a;struct 1.1 概念 是一种自定义的数据类型结构体是构造类型的一种不同数据类型的集合地址空间连续&#xff0c;每次分配最大数据类型的宽度占用内存为所有变…
阅读更多...
插入排序之表插入排序

插入排序之表插入排序

1.表插入排序只是求得一个有序的链表&#xff0c;它是修改指针的值来代替移动记录&#xff0c;操作过程如下 2.但是这样只能进行顺序查找&#xff0c;不能进行随机查找&#xff0c;为了能实现有序表的折半查找&#xff0c;需要对记录进行重新排列。操作过程如下&#xff1a; 3.…
阅读更多...
电容降压LED驱动电路

电容降压LED驱动电路

电容降压电路具有体积小、成本低、电流相对稳定等优点&#xff0c;可应用于小功率的LED驱动电路中&#xff0c;本文主要介绍了电容降压电路的基本电路 图一&#xff1a; 电容降压式简易电源的基本原理如图一所示&#xff0c;C3为降压电容器&#xff1b;D4为半波整流二极管&…
阅读更多...
延时电路分析

延时电路分析

延时电路经常会用到&#xff0c;RC电路是比较简单的电路。在电路设计中经常会用到将电阻和电容正极连接&#xff0c;电阻另一端接上电源&#xff0c;电容负极接地。 简单的延时电路 上面就是延时的电路图了&#xff0c;延时的时间为T-ln((VCC-Vout)/VCC)RC&#xff0c;公式中的…
阅读更多...
恒流电路的分析(一)

恒流电路的分析(一)

在这里分析一个简单的LED恒流电路&#xff0c;软件采用Multisim进行波形采集 一、元器件 R1为80KΩ左右的金属膜电阻&#xff1b;Q选取耐压值超过350V的VPN三极管&#xff1b;D选取2V左右的稳压二极管(如1N4680)&#xff1b;C2选取10V、100UF以上的电解电容&#xff1b;R2选择…
阅读更多...
ST-LINK USB communication error解决方法

ST-LINK USB communication error解决方法

今天在用stlink-v2下载程序时出现ST-LINK USB communication error&#xff0c;突然就出现了这个问题&#xff0c;在网上找了好多解决办法都不可以用&#xff0c;下面给出我的解决方案&#xff0c;文章末尾给出了网上的几种解决办法&#xff0c;仅供参考。 第一步&#xff1a;找…
阅读更多...
ajax实现上传文件

ajax实现上传文件

1.html部分 <input style"width: 280px" type"file" name"upLoadProjectPlan" id"upLoadProjectPlan" value"<%taskAppend.getTaskAllocationDoc()%>"/><a style"float: right; margin-right: 40px&qu…
阅读更多...
利用STM32制作红外测温仪之硬件设计

利用STM32制作红外测温仪之硬件设计

最近受疫情的影响详细大家都在家里没事干&#xff0c;这里利用stm32最小系统做一个红外测温仪 这篇教程里我们来制作红外测温仪需要用到的硬件&#xff0c;关于PCB的工程文件&#xff0c;后文会给出。 &#xff08;一&#xff09;系统分析 由于我们的功能比较单一&#xff0c;…
阅读更多...
如何在博客中插入背景音乐

如何在博客中插入背景音乐

1.首先进入网音乐官方网站&#xff1b; 2.查找自己喜欢的歌&#xff0c;看到如下界面 3.点击"生成外链播放器" 4.看到下面的html代码了吗&#xff1f;将代码进行复制。 5.进入博客园&#xff0c;点击 "管理" ->"设置"&#xff0c; 将代码复制…
阅读更多...
常用存储器介绍

常用存储器介绍

注意&#xff1a;"易失/非易失"是指存储器断电后&#xff0c;它存储的数据内容是否会丢失的特性。 &#xff08;一&#xff09;RAM和ROM 1.1 RAM RAM即随机存储器&#xff0c;它是指存储器中的数据被读入或者写入与信息所在位置无关&#xff0c;时间都是相同的 1…
阅读更多...
TortoiseGit与github实现项目的上传

TortoiseGit与github实现项目的上传

1. 下载并安装相关软件 这里主要涉及的软件包括msysgit和TortoiseGit。 msysgit的下载地址&#xff1a;http://msysgit.googlecode.com/files/Git-1.7.4-preview20110204.exe TortoiseGit的下载地址&#xff1a;http://code.google.com/p/tortoisegit/downloads/list&#xff0…
阅读更多...
Uboot启动

Uboot启动

&#xff08;一&#xff09;uboot 配置编译分析 u-boot源码是通过gcc和Makefile组织编译的&#xff0c;顶层目录下的Makefile可通过boards.cfg来设置开发板的定义 然后递归调用各级子目录下的Makefile&#xff0c;把编译过的程序连接成u-boot boards.cfg文件&#xff1a; 开发…
阅读更多...
行列式计算的两种方法

行列式计算的两种方法

#include<iostream> #include<cstring> #include<cstdio> #include<algorithm> #define N 100 using namespace std; int a[N][N]; double aa[N][N]; int n;/**********************************************************/ //求行列式的值&#xff1…
阅读更多...
uboot启动流程分析

uboot启动流程分析

Uboot的启动流程分为两个阶段&#xff0c;第一阶段主要是汇编语言编写&#xff0c;第二阶段是C语言编写&#xff0c;每个阶段所做的工作不同&#xff0c;这篇文章分析的是uboot 2010版&#xff0c;以tiny4412的uboot为例。 启动过程涉及的主要文件&#xff1a; arch/arm/cpu/a…
阅读更多...
（一）uboot的移植与制作

（一）uboot的移植与制作

目录&#xff08;一&#xff09;环境&#xff08;二&#xff09;流程分析&#xff08;三&#xff09;具体步骤在裸机启动流程里涉及到BL1&#xff0c;BL2为系统的加载启动项&#xff0c;全称为BootLoader。 Boot Loader 是在操作系统内核运行之前运行的一段小程序。通过这段小程…
阅读更多...
jquery ajax（实现单独提交某个form）

jquery ajax（实现单独提交某个form）

function submitTaskScore(formid) {//formid表示的是表单的id$.ajax({type:"post",url:"companyAndDistributeAction!scoreTask",//后台处理程序data:$(formid).serialize(),success:function(){document.getElementById("hjzggContent").inner…
阅读更多...
（二）linux内核镜像制作

（二）linux内核镜像制作

&#xff08;一&#xff09;目的 在进行嵌入式开发的时候&#xff0c;我们往往会先在电脑上安装交叉编译器&#xff0c;然后编译目标板上的代码&#xff0c;最后把代码下载到电路板中&#xff0c;嵌入式系统组成包括&#xff1a;BootLoaderkernelfilesystemapplication&#x…
阅读更多...
js+css实现骰子的随机转动

js+css实现骰子的随机转动

网上找的例子&#xff0c;然后增添了新的东西&#xff0c;在这里展示一下...... 效果图预览&#xff1a; <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html x…
阅读更多...
linux安装交叉编译环境

linux安装交叉编译环境

&#xff08;一&#xff09;交叉编译器的简介 &#xff08;1&#xff09;本地编译 在了解交叉编译之前我们首先介绍一下另一个概念&#xff1a;本地编译 之前所做的C开发属于本地编译&#xff0c;即在当前PC下&#xff08;x86的CPU下&#xff09;&#xff0c;直接编译出可以运…
阅读更多...
jsp实现邮件的发送

jsp实现邮件的发送

如果程序出现 454 Authentication failed, please open smtp flag first! 错误&#xff0c;那么一般是邮箱没有开通POP3/SMTP服务&#xff0c;登录邮箱&#xff0c;在设置中开启该服务即可 &#xff01; 另外需要的jar包如下: imap.jar, mail.jar, smtp.jar, 可以自己在网上下…
阅读更多...
最新文章

Copyright @ 2022~2023