2019獨角獸企業重金招聘Python工程師標準>>>

直接插入排序
說明：逐個將后一個數加到前面的排好的序中。在直接插入排序過程中，對其中一個記錄的插入排序稱為一次
排序；直接插入排序是從第二個記錄開始進行的，因此，長度為n的記錄序列需要進行n-1次排序才能完成整個
序列的排序。時間復雜度為O(n2)。

/*用直接插入法對x[0]-x[n-1]排序*/
void InsertSort(elemtype x[],int n) {
int i,j;
elemtype s;
for(i=0;i<n-1;i++) {
? s=x[i+1];
? ? j=i;
? ? while(j>-1&&s.key<x[j].key){
?? ? x[j+1]=x[j];
?? ? j--;
?? }
???????? x[j+1]=s;
}
}

Java 代碼實現
public static void main(String[] args) {
int[] a = { 4, 3, 7, 1, 6 };
int use = 0;
int j = 0;
for (int i = 0; i < 4; i++) {
use = a[i + 1];
j = i;
while (j > -1 && use < a[j]) {
a[j + 1] = a[j];
j--;
}
//再每一次排完后，把use放到合適的位置
a[j + 1] = use;
}

for (int i = 0; i < 5; i++) {
System.out.println(a[i]);
}
}
－－－－－－－－－－－－－－－－－－－－－
希爾排序
說明：希爾排序又稱縮小增量排序，增量di可以有各種不同的取法，但最后一次排序時的增量必須為1，最簡

單可取di+1=di/2（取小）。時間復雜度為O(n(log2n)2)。

void ShellSort(elemtype x[],int n,intd[],int Number)
/*用希爾排序法對記錄x[0]-x[n-1]排序，d為增量值數組*/
/*Number為增量值個數，各組內采用直接插入法排序*/
{
int i,j,k,m,Span;
elemtype s;
for(m=0;m<Number;m++)
{
??? Span=d[m];
??? for(k=0;k<Span;k++)
??? {
???? for(i=k;i<n-1;i+=Span)/*這個for之后的是“組內采用直接插入法排序”*/
????? {
?????? s=x[i+Span];
?????? j=i;
?????? while(j>-1&&s.key<x[j].key)
?????? {
???????? x[j+Span]=x[j];
???????? j-=Span;
?????? }
?????? x[j+Span]=s;
????? }
??? }
}
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－
直接選擇排序
說明：每次將后面的最小的找出來插入前面的已排好的序中。同理，具有n個記錄的序列要做n-1次排序。
時間復雜度為O(n2)。
void SelectSort(elemtype x[],int n)
/*用直接選擇排序法對x[0]-x[n-1]排序*/
{
int i,j,Small;
elemtype Temp;
for(i=0;i<n-1;i++)
{
??? Small=i;
??? for(j=i+1;j<n;j++)
???? if(x[j].key<x[Small].key)
?????? Small=j;
???
??? if(Small!=i)
???? {
?????? Temp=x[i];
?????? x[i]=x[Small];
?????? x[Small]=Temp;
???? }
}
}
Java代碼實現
public static void main(String[] args) {
int[] x = { 4, 3, 7, 1, 6 };
int i, j, Small;
int Temp;
for (i = 0; i < 4; i++) {
Small = i;
for (j = i + 1; j < 5; j++)
if (x[j] < x[Small])
Small = j;

if (Small != i) {
Temp = x[i];
x[i] = x[Small];
x[Small] = Temp;
}
}
for(i = 0; i < 5; i++){
System.out.println(x[i]);
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－
冒泡排序
說明：兩個兩個比較，將大的往后移。通過第一次冒泡排序，使得待排序的n個記錄中關鍵字最大的記錄排到

了序列的最后一個位置上。然后對序列中前n-1個記錄進行第二次冒泡排序。。。對于n個記錄的序列，共需進

行n次冒泡排序。時間復雜度為O(n2)。

void BubbleSort(elemtype x[],int n)
/*用冒泡排序法對x[0]-x[n-1]排序*/
{
int i,j,flag=1;
elemtype Temp;
for(i=1;i<n&&flag==1;i++)
{
??? flag=0;
??? for(j=0;j<n-i;j++)
??? {
????? if(x[j].key>x[j+1].key)
?????? {
????????? flag=1;
????????? Temp=x[j];
????????? x[j]=x[j+1];
????????? x[j+1]=Temp;
?????? }
??? }
}
}
Java代碼實現
public static void main(String[] args) {
int[] a = { 4, 3, 7, 1, 6 };
int i, j;
int Temp;
for (i = 1; i < 5 ; i++) {
for (j = 0; j < 5 - i; j++) {
if (a[j] > a[j + 1]) {
Temp = a[j];
a[j] = a[j + 1];
a[j + 1] = Temp;
}
}
}
for (i = 0; i < 5; i++) {
System.out.println(a[i]);
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
快速排序
說明：又叫分區交換排序，是對冒泡排序方法的一種改進。時間復雜度為O(nlog2n)。

void QuickSort(elemtype x[],int low,int high)
/*用遞歸方法對記錄x[0]-x[n-1]進行快速排序*/
{
int i,j;
elemtype Temp;

i=low;
j=high;
Temp=x[low];

while(i<j)
{
??? /*在序列的右端掃描*/
??? while(i<j&&Temp.key<=x[j].key)j--;
??? if(i<j)
??? {
????? x[i]=x[j];
????? i++;
??? }

??? /*在序列的左端掃描*/
??? while(i<j&&x[i].key<Temp.key)i++;
??? if(i<j)
??? {
????? x[j]=x[i];
????? j--;
??? }
}
??? x[i]=Temp;

?? /*對子序列進行快速排序*/
?? if(low<i-1)QuickSort(x,low,i-1);
?? if(j+1<high)QuickSort(x,j+1,high);
}

－－－－－－－－－－－－－－－－－－－－－－－－－
歸并排序
說明：所謂歸并排序就是將兩個或兩個以上的有序數據序列合并成一個有序數據序列的過程。
時間復雜度為O(nlog2n)。

void merge(r,l,m,h,r1,r2)/*r[l,m]及r[m+1,h]分別有序，歸并后置于r2中*/
sqlist r,r2;
int l,m,h;
{
int i,j,k;
k=l;/*k是r2的指示器，i、j分別為s1、s2的指示器*/
i=l;
j=m+1;

while(i<=m&&j<=h)
{
??? if(r[i].key<=r[j].key)
???? {
??????? r2[k]=r[i];
??????? i++;
???? }
??? else
???? {
??????? r2[k]=r[j];
??????? j++;
???? }
??? k++;
}
if(i>m) /*s1結束*/
?? while(j<=h)
?? {
??? r2[k]=r[j];
??? j++;k++;
?? }
else XML文件解析的4種方式
?? while(i<=m)
??? {
????? r2[k]=r[i];
????? i++;k++;
??? }
}

轉載于:https://my.oschina.net/linuxred/blog/17592

總結

以上是生活随笔為你收集整理的数据结构算法的一些归纳的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。