排序算法总结

最新推荐文章于 2023-04-05 09:51:20 发布
最新推荐文章于 2023-04-05 09:51:20 发布
阅读量570 收藏
点赞数
分类专栏： DELPHI 
<pre name="code" class="html">unit unit2;

interface

// 冒泡排序
procedure BubbleSort(var abc: array of Integer);

// 摇动排序
procedure ShakerSort(var abc: array of Integer);

// 梳子排序
procedure CombSort(var abc: array of Integer);

// 选择排序
procedure SelectionSort(var abc: array of Integer);

// 标准插入排序
procedure InsertionSortStd(var abc: array of Integer);

// 优化的插入排序
procedure InsertionSort(var abc: array of Integer);

// 希尔排序
procedure ShellSort(var abc: array of Integer);

// 标准归并排序
procedure MergeSortStd(var abc: array of Integer);

// 优化的归并排序
procedure MergeSort(var abc: array of Integer);

// 标准快速排序
procedure QuickSortStd(var abc: array of Integer);

// 无递归的快速排序
procedure QuickSortNoRecurse(var abc: array of Integer);

// 随机的快速排序
procedure QuickSortRandom(var abc: array of Integer);

// 中间值的快速排序
procedure QuickSortMedian(var abc: array of Integer);

// 优化的插入快速排序
procedure QuickSort(var abc: array of Integer);

// 堆排序
procedure HeapSort(var abc: array of Integer);

implementation

// 冒泡排序
procedure BubbleSort(var abc: array of Integer);
var
  i, j: Integer;
  Temp: Integer;
  Done: boolean;
begin
  for i := 0 to High(abc) do
  begin
    Done  := true;
    for j := High(abc) + 1 downto 0 do
      if abc[j] < abc[j - 1] then
      begin
        Temp       := abc[j];
        abc[j]     := abc[j - 1];
        abc[j - 1] := Temp;
        Done       := false;
      end;
    if Done then
      Exit;
  end;
end;

// 梳子排序
procedure CombSort(var abc: array of Integer);
var
  i, j: Integer;
  Temp: Integer;
  Done: boolean;
  Gap:  Integer;
begin
  Gap := High(abc);
  repeat
    Done := true;
    Gap  := (longint(Gap) * 10) div 13;
    if (Gap < 1) then
      Gap := 1
    else if (Gap = 9) or (Gap = 10) then
      Gap := 11;
    for i := 0 to (High(abc) - Gap) do
    begin
      j := i + Gap;
      if abc[j] < abc[i] then
      begin
        Temp   := abc[j];
        abc[j] := abc[i];
        abc[i] := Temp;
        Done   := false;
      end;
    end;
  until Done and (Gap = 1);
end;

// 标准插入排序
procedure InsertionSortStd(var abc: array of Integer);
var
  i, j: Integer;
  Temp: Integer;
begin
  for i := 0 to High(abc) do
  begin
    Temp := abc[i];
    j    := i;
    while (j > 0) and (Temp < abc[j - 1]) do
    begin
      abc[j] := abc[j - 1];
      dec(j);
    end;
    abc[j] := Temp;
  end;
end;

// 优化的插入排序
procedure InsertionSort(var abc: array of Integer);
var
  i, j:       Integer;
  IndexOfMin: Integer;
  Temp:       Integer;
begin
  IndexOfMin := 0;
  for i      := 0 to High(abc) do
    if abc[i] < abc[IndexOfMin] then
      IndexOfMin := i;
  if (0 <> IndexOfMin) then
  begin
    Temp            := abc[0];
    abc[0]          := abc[IndexOfMin];
    abc[IndexOfMin] := Temp;
  end;
  for i := 0 + 2 to High(abc) do
  begin
    Temp := abc[i];
    j    := i;
    while Temp < abc[j - 1] do
    begin
      abc[j] := abc[j - 1];
      dec(j);
    end;
    abc[j] := Temp;
  end;
end;

// 选择排序
procedure SelectionSort(var abc: array of Integer);
var
  i, j:       Integer;
  IndexOfMin: Integer;
  Temp:       Integer;
begin
  for i := 0 to High(abc) do
  begin
    IndexOfMin := i;
    for j      := i to High(abc) + 1 do
      if abc[j] < abc[IndexOfMin] then
        IndexOfMin  := j;
    Temp            := abc[i];
    abc[i]          := abc[IndexOfMin];
    abc[IndexOfMin] := Temp;
  end;
end;

// 摇动排序
procedure ShakerSort(var abc: array of Integer);
var
  i:          Integer;
  Temp:       Integer;
  iMin, iMax: Integer;
begin
  iMin := 0;
  iMax := High(abc) - Low(abc) + 1;

  while (iMin < iMax) do
  begin
    for i := iMax downto 0 do
      if abc[i] < abc[i - 1] then
      begin
        Temp       := abc[i];
        abc[i]     := abc[i - 1];
        abc[i - 1] := Temp;
      end;
    inc(iMin);
    for i := 0 to iMax do
      if abc[i] < abc[i - 1] then
      begin
        Temp       := abc[i];
        abc[i]     := abc[i - 1];
        abc[i - 1] := Temp;
      end;
    dec(iMax);
  end;
end;

// 希尔排序
procedure ShellSort(var abc: array of Integer);
var
  i, j:  Integer;
  h:     Integer;
  Temp:  Integer;
  Ninth: Integer;
begin
  h     := 1;
  Ninth := High(abc) div 9;
  while (h <= Ninth) do
    h := (h * 3) + 1;
  while (h > 0) do
  begin
    for i := h to High(abc) do
    begin
      Temp := abc[i];
      j    := i;
      while (j >= (0 + h)) and (Temp < abc[j - h]) do
      begin
        abc[j] := abc[j - h];
        dec(j, h);
      end;
      abc[j] := Temp;
    end;
    h := h div 3;
  end;
end;

// 标准归并排序
procedure MergeSortStd(var abc: array of Integer);
  procedure MSS(var abc: array of Integer; aFirst: Integer; aLast: Integer; aTempList: array of Integer);
  var
    Mid:        Integer;
    i, j:       Integer;
    ToInx:      Integer;
    FirstCount: Integer;
  begin
    Mid := (aFirst + aLast) div 2;
    if (aFirst < Mid) then
      MSS(abc, aFirst, Mid, aTempList);
    if (succ(Mid) < aLast) then
      MSS(abc, succ(Mid), aLast, aTempList);
    FirstCount := succ(Mid - aFirst);
    Move(abc[aFirst], aTempList[0], FirstCount * sizeof(pointer));
    i     := 0;
    j     := succ(Mid);
    ToInx := aFirst;
    while (i < FirstCount) and (j <= aLast) do
    begin
      if (aTempList[i] <= abc[j]) then
      begin
        abc[ToInx] := aTempList[i];
        inc(i);
      end
      else
      begin
        abc[ToInx] := abc[j];
        inc(j);
      end;
      inc(ToInx);
    end;
    if (i < FirstCount) then
      Move(aTempList[i], abc[ToInx], (FirstCount - i) * sizeof(pointer));
  end;

var
  TempList: array of Integer;
begin
  if (0 < High(abc)) then
  begin
    SetLength(TempList, High(abc) div 2);
    MSS(abc, 0, High(abc), TempList);
  end;
end;

// 优化的归并排序
procedure MergeSort(var abc: array of Integer);
const
  MSCutOff = 15;

  procedure MSInsertionSort(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    i, j:       Integer;
    IndexOfMin: Integer;
    Temp:       Integer;
  begin
    IndexOfMin := aFirst;
    for i      := succ(aFirst) to aLast do
      if abc[i] < abc[IndexOfMin] then
        IndexOfMin := i;
    if (aFirst <> IndexOfMin) then
    begin
      Temp            := abc[aFirst];
      abc[aFirst]     := abc[IndexOfMin];
      abc[IndexOfMin] := Temp;
    end;
    for i := aFirst + 2 to aLast do
    begin
      Temp := abc[i];
      j    := i;
      while Temp < abc[j - 1] do
      begin
        abc[j] := abc[j - 1];
        dec(j);
      end;
      abc[j] := Temp;
    end;
  end;

  procedure MS(var abc: array of Integer; aFirst: Integer; aLast: Integer; aTempList: array of Integer);
  var
    Mid:        Integer;
    i, j:       Integer;
    ToInx:      Integer;
    FirstCount: Integer;
  begin
    Mid := (aFirst + aLast) div 2;
    if (aFirst < Mid) then
      if (Mid - aFirst) <= MSCutOff then
        MSInsertionSort(abc, aFirst, Mid)
      else
        MS(abc, aFirst, Mid, aTempList);
    if (succ(Mid) < aLast) then
      if (aLast - succ(Mid)) <= MSCutOff then
        MSInsertionSort(abc, succ(Mid), aLast)
      else
        MS(abc, succ(Mid), aLast, aTempList);
    FirstCount := succ(Mid - aFirst);
    Move(abc[aFirst], aTempList[0], FirstCount * sizeof(pointer));
    i     := 0;
    j     := succ(Mid);
    ToInx := aFirst;
    while (i < FirstCount) and (j <= aLast) do
    begin
      if (aTempList[i] <= abc[j]) then
      begin
        abc[ToInx] := aTempList[i];
        inc(i);
      end
      else
      begin
        abc[ToInx] := abc[j];
        inc(j);
      end;
      inc(ToInx);
    end;
    if (i < FirstCount) then
      Move(aTempList[i], abc[ToInx], (FirstCount - i) * sizeof(pointer));
  end;

var
  TempList: array of Integer;
begin
  if (0 < High(abc)) then
  begin
    SetLength(TempList, High(abc) div 2);
    MS(abc, 0, High(abc), TempList);
  end;
end;

// 标准快速排序
procedure QuickSortStd(var abc: array of Integer);
  procedure QSS(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    L, R:  Integer;
    Pivot: Integer;
    Temp:  Integer;
  begin
    while (aFirst < aLast) do
    begin
      Pivot := abc[(aFirst + aLast) div 2];
      L     := pred(aFirst);
      R     := succ(aLast);
      while true do
      begin
        repeat
          dec(R);
        until (abc[R] <= Pivot);

        repeat
          inc(L);
        until (abc[L] >= Pivot);

        if (L >= R) then
          Break;

        Temp   := abc[L];
        abc[L] := abc[R];
        abc[R] := Temp;
      end;
      if (aFirst < R) then
        QSS(abc, aFirst, R);
      aFirst := succ(R);
    end;
  end;

begin
  QSS(abc, 0, High(abc));
end;

// 无递归的快速排序
procedure QuickSortNoRecurse(var abc: array of Integer);
  procedure QSNR(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    L, R:  Integer;
    Pivot: Integer;
    Temp:  Integer;
    Stack: array [0 .. 63] of Integer; { allows for 2 billion items }
    SP:    Integer;
  begin
    Stack[0] := aFirst;
    Stack[1] := aLast;
    SP       := 2;
    while (SP <> 0) do
    begin
      dec(SP, 2);
      aFirst := Stack[SP];
      aLast  := Stack[SP + 1];
      while (aFirst < aLast) do
      begin
        Pivot := abc[(aFirst + aLast) div 2];
        L     := pred(aFirst);
        R     := succ(aLast);
        while true do
        begin
          repeat
            dec(R);
          until (abc[R] <= Pivot);
          repeat
            inc(L);
          until (abc[L] >= Pivot);
          if (L >= R) then
            Break;
          Temp   := abc[L];
          abc[L] := abc[R];
          abc[R] := Temp;
        end;
        if (R - aFirst) < (aLast - R) then
        begin
          Stack[SP]     := succ(R);
          Stack[SP + 1] := aLast;
          inc(SP, 2);
          aLast := R;
        end
        else
        begin
          Stack[SP]     := aFirst;
          Stack[SP + 1] := R;
          inc(SP, 2);
          aFirst := succ(R);
        end;
      end;
    end;
  end;

begin
  QSNR(abc, 0, High(abc));
end;

// 随机的快速排序
procedure QuickSortRandom(var abc: array of Integer);
  procedure QSR(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    L, R:  Integer;
    Pivot: Integer;
    Temp:  Integer;
  begin
    while (aFirst < aLast) do
    begin
      R      := aFirst + Random(aLast - aFirst + 1);
      L      := (aFirst + aLast) div 2;
      Pivot  := abc[R];
      abc[R] := abc[L];
      abc[L] := Pivot;
      L      := pred(aFirst);
      R      := succ(aLast);
      while true do
      begin
        repeat
          dec(R);
        until (abc[R] <= Pivot);
        repeat
          inc(L);
        until (abc[L] >= Pivot);
        if (L >= R) then
          Break;
        Temp   := abc[L];
        abc[L] := abc[R];
        abc[R] := Temp;
      end;
      if (aFirst < R) then
        QSR(abc, aFirst, R);
      aFirst := succ(R);
    end;
  end;

begin
  QSR(abc, 0, High(abc));
end;

// 中间值的快速排序
procedure QuickSortMedian(var abc: array of Integer);
  procedure QSM(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    L, R:  Integer;
    Pivot: Integer;
    Temp:  Integer;
  begin
    while (aFirst < aLast) do
    begin
      if (aLast - aFirst) >= 2 then
      begin
        R := (aFirst + aLast) div 2;
        if (abc[aFirst] > abc[R]) then
        begin
          Temp        := abc[aFirst];
          abc[aFirst] := abc[R];
          abc[R]      := Temp;
        end;
        if (abc[aFirst] > abc[aLast]) then
        begin
          Temp        := abc[aFirst];
          abc[aFirst] := abc[aLast];
          abc[aLast]  := Temp;
        end;
        if (abc[R] > abc[aLast]) then
        begin
          Temp       := abc[R];
          abc[R]     := abc[aLast];
          abc[aLast] := Temp;
        end;
        Pivot := abc[R];
      end
      else
        Pivot := abc[aFirst];
      L       := pred(aFirst);
      R       := succ(aLast);
      while true do
      begin
        repeat
          dec(R);
        until (abc[R] <= Pivot);
        repeat
          inc(L);
        until (abc[L] >= Pivot);
        if (L >= R) then
          Break;
        Temp   := abc[L];
        abc[L] := abc[R];
        abc[R] := Temp;
      end;
      if (aFirst < R) then
        QSM(abc, aFirst, R);
      aFirst := succ(R);
    end;
  end;

begin
  QSM(abc, 0, High(abc));
end;

// 优化插入的快速排序
procedure QuickSort(var abc: array of Integer);
const
  QSCutOff = 15;

  procedure QSInsertionSort(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    i, j:       Integer;
    IndexOfMin: Integer;
    Temp:       Integer;
  begin
    IndexOfMin := aFirst;
    j          := aFirst + QSCutOff; { !!.01 }
    if (j > aLast) then
      j   := aLast;
    for i := succ(aFirst) to j do
      if abc[i] < abc[IndexOfMin] then
        IndexOfMin := i;
    if (aFirst <> IndexOfMin) then
    begin
      Temp            := abc[aFirst];
      abc[aFirst]     := abc[IndexOfMin];
      abc[IndexOfMin] := Temp;
    end;
    { now sort via fast insertion method }
    for i := aFirst + 2 to aLast do
    begin
      Temp := abc[i];
      j    := i;
      while Temp < abc[j - 1] do
      begin
        abc[j] := abc[j - 1];
        dec(j);
      end;
      abc[j] := Temp;
    end;
  end;

  procedure QS(var abc: array of Integer; aFirst: Integer; aLast: Integer);
  var
    L, R:  Integer;
    Pivot: Integer;
    Temp:  Integer;
    Stack: array [0 .. 63] of Integer; { allows for 2 billion items }
    SP:    Integer;
  begin
    Stack[0] := aFirst;
    Stack[1] := aLast;
    SP       := 2;

    while (SP <> 0) do
    begin
      dec(SP, 2);
      aFirst := Stack[SP];
      aLast  := Stack[SP + 1];

      while ((aLast - aFirst) > QSCutOff) do
      begin
        R := (aFirst + aLast) div 2;
        if (abc[aFirst] > abc[R]) then
        begin
          Temp        := abc[aFirst];
          abc[aFirst] := abc[R];
          abc[R]      := Temp;
        end;
        if (abc[aFirst] > abc[aLast]) then
        begin
          Temp        := abc[aFirst];
          abc[aFirst] := abc[aLast];
          abc[aLast]  := Temp;
        end;
        if (abc[R] > abc[aLast]) then
        begin
          Temp       := abc[R];
          abc[R]     := abc[aLast];
          abc[aLast] := Temp;
        end;
        Pivot := abc[R];

        L := aFirst;
        R := aLast;
        while true do
        begin
          repeat
            dec(R);
          until (abc[R] <= Pivot);
          repeat
            inc(L);
          until (abc[L] >= Pivot);
          if (L >= R) then
            Break;
          Temp   := abc[L];
          abc[L] := abc[R];
          abc[R] := Temp;
        end;

        if (R - aFirst) < (aLast - R) then
        begin
          Stack[SP]     := succ(R);
          Stack[SP + 1] := aLast;
          inc(SP, 2);
          aLast := R;
        end
        else
        begin
          Stack[SP]     := aFirst;
          Stack[SP + 1] := R;
          inc(SP, 2);
          aFirst := succ(R);
        end;
      end;
    end;
  end;

begin
  QS(abc, 0, High(abc));
  QSInsertionSort(abc, 0, High(abc));
end;

// 堆排序
procedure HeapSort(var abc: array of Integer);
  procedure HSTrickleDown(var abc: array of Integer; root, count: Integer);
  var
    KKK: Integer;
  begin
    abc[0] := abc[root];
    KKK    := 2 * root;
    while KKK <= count do
    begin
      if (KKK < count) and (abc[KKK] < abc[KKK + 1]) then
        inc(KKK);
      if abc[0] < abc[KKK] then
      begin
        abc[root] := abc[KKK];
        root      := KKK;
        KKK       := 2 * root;
      end
      else
        KKK := count + 1;
    end;
    abc[root] := abc[0];
  end;

var
  Inx:       Integer;
  ItemCount: Integer;
  tmp:       Integer;
begin
  ItemCount := High(abc) - Low(abc) + 1;
  for Inx   := ItemCount div 2 downto 1 do
  begin
    HSTrickleDown(abc, Inx, ItemCount);
  end;

  for Inx := ItemCount downto 2 do
  begin
    tmp      := abc[1];
    abc[1]   := abc[Inx];
    abc[Inx] := tmp;
    HSTrickleDown(abc, 1, Inx - 1);
  end;
end;

end.



                

        

        

    




    

      

        

            

              
                
                  郁闷的坦然
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
C#排序算法总结

				
			

			

				

					09-18
				

			

		

		

			
				
C#排序算法总结：交换排序：最基础的冒泡排序，冒泡排序的优化版选择排序和快速排序，插入排序：直接插入排序和折半插入排序。

			
		

	



                

              
                



	

		

			

				
					
为方便大家学习使用QSS特作此整合

				
			

			

				

					高人是高人的博客
				

				

					12-07
					
					616
					
				

			

		

		

			
				
QSS样式设计三件套为方便大家学习使用QSS特作此整合QSS EditorRizek Qss EditorKineticwing IDE
为方便大家学习使用QSS特作此整合
Qt Creator 对于 QSS 的支持的不是很好，没有语法提示、智能纠错、实时预览等功能，这在一定程度上明显降低了开发效率。资源包含几款 QSS 编辑IDE工具，用于辅助基本开发。可以工具自己的喜好来选择对应的IDE。
Q...

			
		

	



                


  
              

                


	

		

			

				
					
在 Qt 开发中使用 Less 简化 qss 维护

				
			

			

				

					简简单单搞技术
				

				

					02-22
					
					851
					
				

			

		

		

			
				
1. 概述
1.1. 使用CSS遇到的问题

多皮肤 CSS 信息冗余. 程序往往有多套皮肤, 而每套皮肤都对应至少一个 CSS, 随着皮肤的增多, 多套CSS的维护成本变得很高. 让我们想想这样一个场景, 设计部对现有皮肤的某一样式做了修改, 我们就得在每套皮肤的CSS中找到该样式的位置, 再一个一个进行修改. 在整个过程中, 有很大部分的时间浪费在了查找和切换文件这些事情上了.
CSS 注释不...

			
		

	





	

		

			

				
					
Qt 编程点滴1

				
			

			

				

					24K程序猿
				

				

					10-12
					
					604
					
				

			

		

		

			
				
MinGw + CodeBlock + Qt 4.5
类定义后面要加";"
函数的实现部分,如果定义部分有void,则实现部分不能少;
检查include文件有无少;
error: request for member `show\\\' in `((MainWindow*)this)->MainWindow::rightform\\\', which is of non-class ty

			
		

	



		

			
		



	

		

			

				
					
快速排序及优化，堆排序总结（上）

				
			

			

				

					BodyCoding
				

				

					03-20
					
					249
					
				

			

		

		

			
				
大二时候学的快排和堆排现在忘的差不多了。。。重新学习了下快排并根据左神的视频进行了优化
经典快排是以最后一个元素作为基准点，随机快排是从集合中随机选择一个数和最后一个元素交换作为基准点，因此经典快排和随机快排的代码相差不大，但是随机快排的复杂度是通过期望得到的，是个概率上的复杂度，运用的更广泛。
优化后的快排主要是参考了荷兰国旗问题，将和基准数相等的数归为一类，这样在接下来的排序中，与基准数相同的...

			
		

	





	

		

			

				
					
召回与排序算法总结

				
			

			

				

					Vensmallzeng的博客
				

				

					04-05
					
					2315
					
				

			

		

		

			
				
粗排(粗排是初筛一般不会上复杂模型)：有时候因为每个用户召回环节返回的物品数量还是太多，怕排序环节速度跟不上，所以可以在召回和精排之间加入一个粗排环节，通过少量用户和物品特征，简单模型，来对召回的结果进行个粗略的排序，在保证一定精准的前提下，进一步减少往后传送的物品数量，粗排往往是可选的，可用可不同，跟场景有关。a. CTR预估：LR，GBDT，FM及其变种（FM是一个工程团队不太强又对算法精度有一定要求时比较好的选择），Wide&Deep，DeepFm，NCF各种交叉，DIN，BERT，RNN。

			
		

	





	

		

			

				
					
C语言排序算法总结

				
			

			

				

					bitezz的博客
				

				

					04-22
					
					4773
					
				

			

		

		

			
				
文章目录前言一、插入排序1.1直接插入排序1.2希尔排序二、使用步骤1.引入库2.读入数据总结

前言
常见的排序算法如下：

一、插入排序
1.1直接插入排序
基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列 。
实际中我们玩扑克牌时，就用了插入排序的思想:
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],a

			
		

	





	

		

			

				
					
十种经典排序算法总结

					
热门推荐

				
			

			

				

					天瑕的博客
				

				

					04-06
					
					1万+
					
				

			

		

		

			
				
如果面试时让你写排序算法，除了说一句Arrays.sort你还会啥？

			
		

	





	

		

			

				
					
Java排序算法总结

				
			

			

				

					12-22
				

			

		

		

			
				
【Java排序算法总结】  在计算机科学中，排序算法是用于对数据进行排列的算法，而Java作为一种广泛应用的编程语言，提供了多种实现排序的方案。以下是对几种常见的Java排序算法的详细解析：  一、冒泡排序 冒泡排序...

			
		

	





	

		

			

				
					
Java实现常见排序算法总结

				
			

			

				

					05-02
				

			

		

		

			
				
【Java实现常见排序算法总结】  排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。  1. **直接插入排序（直接插入排序...

			
		

	





	

		

			

				
					
ASP外观专利图像检索平台(源代码+论文).rar

				
			

			

				

					07-21
				

			

		

		

			
				
ASP外观专利图像检索平台(源代码+论文)

			
		

	





	

		

			

				
					
C++课程设计：电煤气管理系统【源码+文档】

				
			

			

				

					07-21
				

			

		

		

			
				
C++课程设计：电煤气管理系统【源码+文档】
本程序是一个水电气管理信息系统，能够对高校的水电气费用进行管理, 包括了成员的基本信息，如学号、编号、姓名、成员水电气的用量等。程序的用途包括缴纳水电气费、查询一个同学水电气费用量、查看所有同学的缴费情况、增加学生信息、删除学生信息、退出系统等。在设计时也考虑到学生和教师在用水电气时的不同，学生可以免费使用一定额度的水电气，超过这个额度的以后必须付费，且付费部分水电气费的价格要高于教工的收费标准，该措施的实行是为了鼓励同学们节约资源，以免造成不必要的资源浪费。该软件主要是为了学校的管理人员提供便捷，以更快的完成水电气费用的收缴。该软件本着简洁明了，实用稳定为一体进行设计。
系统将实现以下功能：
（1）实现对用户信息的录入；
（2）实现水电煤气数据的录入；
（3）实现计算并查询用户应缴费用，查询未缴纳费用的名单；
（4）实现对人员的删除和添加；

			
		

	





	

		

			

				
					
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）.rar

				
			

			

				

					07-21
				

			

		

		

			
				
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）

			
		

	





	

		

			

				
					
avaloniassification-mas笔记

					
最新发布

				
			

			

				

					07-21
				

			

		

		

			
				
avalonia

			
		

	





	

		

			

				
					
ASP+ACCESS学生排课管理系统毕业设计(源代码+论文).rar

				
			

			

				

					07-21
				

			

		

		

			
				
ASP+ACCESS学生排课管理系统毕业设计(源代码+论文)

			
		

	





	

		

			

				
					
ASP+ACCESS在线教育系统设计(源代码+论文).rar

				
			

			

				

					07-21
				

			

		

		

			
				
ASP+ACCESS在线教育系统设计(源代码+论文)

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值