選擇演算法的實現
可以這樣做：
public class Print {
public static void main(String[] args) {
int[] a = {4,7,1,3,9};
System.out.println("原來的：");
print(a);
selectionSort(a);
System.out.println("排序後：");
print(a);
}
//Java中數組是引用類型，所以在方法中操作數組可以改變它的內容
private static void selectionSort(int[] a) {
int k, temp;
for(int i=0; i<a.length; i++) {
k = i;//保護i,不能讓i的值在下面比較時變了
for(int j=k+1; j<a.length; j++) {
if(a[j] < a[k]) {
k = j;
}
}
if(k != i) {
temp = a[i];
a[i] = a[k];
a[k] = temp;
}
}
}
private static void print(int[] a) {
for(int i=0; i<a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}
}
② 用C++語言結構怎麼實現在大量的數中快速選擇的演算法
先將數據讀入到內存，然後進行排序，再用二分法查找，這樣應該不會很慢。沒有必要用多線程處理。
③ 題目1:一個簡單的演算法演示程序(JAVA語言實現)
1. 選擇一個演算法（提供選擇見下），利用各種方法（圖形、動畫等）演示演算法的演示過程。
2. 可以進行手動演示，也可以自動步進式演示。
3. 允許用戶設置演算法的各個輸入參數，以及自動步進式演示中的時間間隔。
4. 不同的演算法輸入要求見下。
界面要求：
1. 盡量使用圖形界面實現，要符合日常軟體使用規范來設計菜單和界面。
2. 如果無法實現圖形界面，則在命令行方式下也需要提供菜單，方便用戶操作。
其他要求：
1. 標識符命名遵循Windows命名規范。
2. 能夠注意各種異常處理，注重提高程序運行效率。
提交內容：
1. 全部源代碼。
2. 軟體設計和使用說明書（UML類圖；實現的功能、主要技術；使用幫助文檔）
參考演算法：
1. 最小生成樹演算法：Prim演算法、Kruskal演算法。允許以下方式輸入一個圖形：繪制圖形、輸入鄰接矩陣、輸入邊及其關聯的頂點。要求在圖形方式下進行演示演算法執行步驟。
2. 單源最短路演算法：Dijkstra演算法。允許以下方式輸入一個圖形：繪制圖形、輸入鄰接矩陣、輸入邊及其關聯的頂點。要求在圖形方式下進行演示演算法執行步驟。
3. 最優編碼演算法：Huffman編碼演算法。允許用戶輸入一段英文文字，或者打開一個txt文檔（英文內容），據此文檔內容進行編碼。要求動態列出每個字元的出現概率統計結果以及對應編碼。
4. 其他可供演示的具有一定難度的演算法，如關鍵路徑問題、有向圖的極大連通分支等。
④ 排序演算法的實現與比較 編程實現直接插入排序、希爾、冒泡排序、快速、選擇排序演算法，並計算每種排序演算法的
void BubbleSort(int Array[],int n)
{//輸入數組進行冒泡排序
bool exchange=true;
for(int i=0;i<n;i++)
{
if(exchange==false)
return;
exchange=false;
for (int j=n-1;j>i;j--)
{
if(Array[j]<Array[j-1])
{
int temp=Array[j];
Array[j]=Array[j-1];
Array[j-1]=temp;
exchange=true;
}
}
}
}
void InsertSort(int Arrauy[],int n)
{//直接插入排序
for (int i=0;i<n-15 ;i++)
{
for (int j=i;j>=0;j--)
{
if (Arrauy[i+1]>Arrauy[j])
{//找到插入位置,在j之後
int temp=Arrauy[i+1];
for(int k=i;k>j;k--)
Arrauy[i]=Arrauy[i+1];
Arrauy[j+1]=temp;
break;
}
}
}
}
void BinaryInsertSort(int Arrary[],int n)
{//二分插入排序
for (int i=0;i<n-1;i++)
{
int temp=Arrary[i+1];
int left=0,right=i;
int mid=(left+right)/2;
while(left<right)
{
if(temp>Arrary[mid])
left=mid+1;
else
right=mid-1;
mid=(left+right)/2;
}
for(int j=i;j>mid;j--)
Arrary[j]=Arrary[j+1];
Arrary[mid+1]=temp;
}
}
void ShellSort(int Array[],int n)
{
//希爾插入排序
int gap=n;
do
{
gap=gap/3+1;
for (int i=gap;i<n;i++)
{//對子序列進行插入排序
int temp=Array[i];
int j=i-gap;
while(j>=0)
{
if (temp<Array[j])
{
Array[j+gap]=Array[j];
j=j-gap;
}
else
{
Array[j+gap]=temp;
break;
}
}
}
}while(gap>1);
}
void QuickSort(int Array[],const int n)
{//快速排序
QuickSort(Array,0,n-1);
}
void QuickSort(int Array[],const int left,const int right)
{//快速排序子過程
if(left<right)
{
int pivotpos= Partition(Array,left,right);
QuickSort(Array,left,pivotpos-1);
QuickSort(Array,pivotpos+1,right);
}
}
int Partition(int Array[],const int left,const int right)
{//劃分過程
int pivot=left;
for (int i=left+1;i<=right;i++)
{
if(Array[i]<Array[left])
{
pivot++;
int temp=Array[i];Array[i]=Array[pivot];Array[pivot]=temp;
}
}
int temp=Array[left];Array[left]=Array[pivot];Array[pivot]=temp;
return pivot;
}
void SelectSort(int Array[],int n)
{
//直接選擇排序
for (int i=0;i<n;i++)
{
int min=i;
for (int j=i;j<n;j++)
{
if(Array[j]<Array[min])
min=j;
}
if(min!=i)
{
int temp=Array[min];Array[min]=Array[i];Array[i]=temp;
}
}
}
時間復雜度 ：
插入，冒泡，選擇 O（n×n）
快速O（nlogn）
希爾 不確定
⑤ 編寫程序，實現三種排序演算法（選擇、插入、冒泡）
選擇排序如下：
#include <stdio.h>
#include <stdlib.h>
void choose_sort( int array[], int s, int e );
int main( void )
{
int array[100];
int num;
int i;
int j;
int k;
printf( "input the amout(<100) of the array:" );
scanf( "%d", &num );
for( i = 0; i < num; i++)
{
scanf( "%d", array + i );
}
choose_sort( array, 0, num - 1 );
/*
for( i = 0; i < num - 1; i++ )
{
k = i;
for( j = i + 1; j < num; j++ )
{
k = array[j] < array[k] ? j : k;
}
if( i != k )
{
array[i] ^= array[k];
array[k] ^= array[i];
array[i] ^= array[k];
}
}
*/
printf( "the result of choose sort:\n" );
for( i = 0; i < num; i++)
{
printf( "%d ", array[i] );
}
printf( "\n" );
system( "pause" );
return 0;
}
void choose_sort( int array[], int s, int e )
{
int i;
int j;
int k;
for( i = s; i < e; i++ )
{
k = i;
for( j = i + 1; j <= e; j++ )
{
k = array[k] > array[j] ? j : k;
}
if( k != i )
{
array[i] ^= array[k];
array[k] ^= array[i];
array[i] ^= array[k];
}
}
}
插入排序如下：
#include <stdio.h>
#include <stdlib.h>
/*/already check */
void insert_sort( int array[], int s, int e );
int main( void )
{
int array[100];
int num;
int i;
int key;
int j;
printf( "input the amount(<100) of array: " );
scanf( "%d", &num );
for( i = 0; i < num; i++ )
{
scanf( "%d", array + i );
}
insert_sort( array, 0, num - 1 );
/*
for( i = 1; i < num; i++ )
{
key = array[i];
j = i - 1;
while( j >= 0 && array[j] > key )
{
array[j + 1] = array[j];
j--;
}
array[j + 1] = key;
}
*/
printf( "insert sort result:\n" );
for( i = 0; i < num; i++ )
{
printf( "%d ", array[i] );
}
printf( "\n" );
system( "pause" );
return 0;
}
void insert_sort( int array[], int s, int e )
{
int i;
int j;
int key;
for( i = s + 1; i <= e; i++)
{
key = array[i];
for( j = i - 1; j >= s && array[j] > key; j-- )
{
array[j + 1] = array[j];
}
array[j + 1] = key;
}
}
冒泡排序如下：
#include <stdio.h>
#include <stdlib.h>
void bubble_sort( int array[], int s, int e );
int main( void )
{
int i;
int num;
int array[100];
printf( "input amount(<100) of number: " );
scanf( "%d", &num );
for( i = 0; i < num; i++ )
{
scanf( "%d", array + i );
}
bubble_sort( array, 0, num - 1 );
printf( "result of bubble sort:\n" );
for( i = 0; i < num; i++ )
{
printf( "%d ", array[i] );
}
printf( "\n" );
system( "pause" );
return 0;
}
/*
void bubble_sort( int array[], int s, int e )
{
int i;
int j;
for( i = e; i > s; i-- )
{
for( j = s + 1; j <= i; j++ )
{
if( array[j - 1] > array[j] )
{
array[j] ^= array[j - 1];
array[j - 1]^= array[j];
array[j] ^= array[j - 1];
}
}
}
}
*/
注意：以上三個演算法的main函數部分是為了讓你輸入一些數來測試排序演算法而寫的，排序的具體實現另寫成一個函數。
補充題：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int search(char* str1, char* str2);
main()
{
char str1[100];
char str2[100];
int result;
printf("input first string: ");
scanf("%s", str1);
printf("input first string: ");
scanf("%s", str2);
result = search(str1, str2);
if(result < 0){
printf("str2 is not in str1.\n");
}
else{
printf("str2 is in str1, and begins at %d.\n", result);
}
system("pause");
}
int search(char* str1, char* str2){
int len1 = strlen(str1);
int len2 = strlen(str2);
int i;
int j;
int k;
i = 0;
while(i <= len1 - len2){
j = 0;
k = i;
while(j < len2 && str1[k] == str2[j]){
j++;
k++;
}
if(j == len2){
return i;
}
i++;
}
return -1;
}
注意：main也是測試用的，具體實現寫成一個函數
⑥ 急！！！！！！求常用演算法的實現與比較（直接選擇、直接插入、冒泡）我要源程序哦，謝謝了
有點暈，這么幾個演算法。
請你看教科書。