coding by python beginner

t0 = [5,2,4,6,1,3]
for i in range( 1, len(t0) ):
    for j in range( i ):
        while t0[i] < t0[j]:
            t0[i], t0[j] = t0[j], t0[i]
print(t0)

파이썬 간단하게 짜 보았습니다.

def insert(a):
    for i in range(1,len(a)):
        for j in range(i-1,-1,-1):
            if a[i] < a[j]:
                tmp = a[i]
                a.pop(i)
                a.insert(i,a[j])
                a.pop(j)
                a.insert(j,tmp)
                i = j

    return a


a = [5,2,4,6,1,3]

print insert(a)

Using python

def InSort(lst):
    for i in range(1,len(lst)):
        for j in range(i):
            if lst[j]>lst[i]:
                lst.insert(j,lst[i])
                lst.pop(i+1)
                break
    return lst

a = [5,2,4,6,1,3,7,9,8,13,11,12]
print InSort(a)

#include <stdio.h>

void swap(int s[], int from, int to) {
    int tmp;
    tmp = s[from];
    s[from] = s[to];
    s[to] = tmp;
}

void printArray(int s[], size_t size) {
    int i;
    for (i=0; i<size; i++) {
        if (i==size-1) {
            printf("%d", s[i]);
        }else {
            printf("%d;", s[i]);
        }
    }
    printf("\n");
}

void insertion_sort(int s[], size_t size) {
    int j;
    int i;
    int swap_position;
    int target;

    for (i=1; i<size; i++) {
        target = s[i];

        /*
         * find swap position
         */
        swap_position = 0;
        for(j=0; j<i; j++) {
            if (target > s[j]) {
                swap_position++;
            }
        }

        /*
         * change seat
         */
        for(j=i; j>swap_position; j--) {
            swap(s, j, j-1);
        }
    }
}


int main() {
    int s[] = {5,2,4,6,1,3};
    int size = sizeof(s)/sizeof(s[0]);

    insertion_sort(s, size);
    printArray(s, size);

    return 0;
}

이동해야 할 인덱스를 찾은 후에 인덱스까지 계속 좌측으로 이동하면서 서로 swap 했습니다.

#include<vector>
#include<iostream>

using namespace std;

template<typename iterator>
void insertion(iterator begin, int from){
    auto pos = begin + from;
    auto value = *(begin + from);
    while(--pos >= begin && (*pos) > value )
        *(pos+1) = *(pos);
    *(pos+1) = value;
}

int main(){
    int num;

    vector<int> v;
    while(cin >> num){
        v.push_back(num);
    }

    int i;
    for(i = 1; i < v.size(); ++i){
        insertion(v.begin(), i);
    }


    for(auto it = v.begin(); it != v.end(); ++it){
        cout << *it << " ";
    }
    return 0;
}

import java.util.Arrays;


public class InsertionSort {
    private int[] numbers=new int[]{5,2,4,6,1,3};

    public void sort(){
        for(int i=1;i<numbers.length;i++){
            int tmp=numbers[i];
            int idx=i-1;
            while((idx>=0) && (numbers[idx]>tmp)){
                numbers[idx+1]=numbers[idx];
                idx--;
            }
            numbers[idx+1]=tmp;
            System.out.println("Changing... "+Arrays.toString(numbers) );
        }
        System.out.println("finally... "+Arrays.toString(numbers));
    }

    public static void main(String args[]){
        new InsertionSort().sort();

    }
}

- result -

Changing... [2, 5, 4, 6, 1, 3]
Changing... [2, 4, 5, 6, 1, 3]
Changing... [2, 4, 5, 6, 1, 3]
Changing... [1, 2, 4, 5, 6, 3]
Changing... [1, 2, 3, 4, 5, 6]
finally ... [1, 2, 3, 4, 5, 6]

#Insertion_Sort.py

def ISort (arr) :
    for i in range(1,len(arr)) :
        target=arr[i]
        pos=i
        for j in range(i-1, -1, -1) :       
            if target>arr[j] :
                break
            else :
                pos=j   

        if pos == i :
            continue
        else :
            arr=Swap(arr, i, pos)
    return arr          

def Swap (arr, i, j) :
    tmp = arr[i]

    for num in range(i, j, -1) :
        arr[num]=arr[num-1]
    arr[j] = tmp

    return arr

arr=[5,2,4,6,1,3,7,9,10,8]

print (ISort(arr))

Python을 이용해서 풀어보았습니다.

def sorting(a):
    for i in range(len(a)-1):
        x = i
        y = i+1
        while x != -1:
            if a[x] > a[y]:
                a[x],a[y] = a[y],a[x]
                x -= 1
                y -= 1
            elif a[x] <= a[y] : break
    print(a)
    return ()

n_list=[5,2,4,6,1,3]
n=len(n_list)

for i in range(n):
    for j in range(i+1,n):
        if n_list[i]>n_list[j]:n_list.insert(i,n_list.pop(j))

print(n_list)

R입니다

insertion.sort=function(v){
  v1=v[1]
  v2=v[-1]
  for(i in v2){   
    if(all(i>v1)) {
      v1=c(v1, i)
    } else if(any(i>v1)){      
      m=max(which(i>v1))
      v1=c(v1[seq(m)], i, v1[seq(m+1, length(v1), by=1)])
    } else {
      v1=c(i, v1) 
    }
  }
  v1
}

insertion.sort(c(5,2,4,6,1,3))

def n2sort(nlist):
i=1
for i in range(len(nlist)):
    s=nlist[i]
    d=nlist[i-1]
    if s<d:
        nlist[i-1]=s
        nlist[i]=d
        j=i-1
        while j > 0:
            s=nlist[j]
            d=nlist[j-1]
            if s<d:
                nlist[j-1]=s
                nlist[j]=d
            if j==0:
                break        
            j=j-1
    i=i+1
return nlist

nlist=[5,2,4,6,1,3]
print(nlist)
print(n2sort(nlist))


첫 코딩이었습니다. 재밌네요. ㅎㅎ

class SortsAlgorithm{
    public SortsAlgorithm() {   }
    public int[] insertionSort(int num[]){
        int key;
        for (int i = 1; i < num.length; i++) {
            key = num[i];
            for (int j = i-1 ; j >= 0 ; j--) {
                if( key < num[j] ){
                    num[j+1] = num[j];
                    num[j] = key;
                }
            }
        }
        return num;
    }   
}

이렇게 하면 되지 않나요 :???

def insertion_sort(l):
    for i in range(len(l)):
        k = l[i]
        for j in range(i):
            if k < l[j]:
                l = l[:i]+l[i+1:]
                l.insert(j, k)
                break
    return l

파이썬 입니다.

# cod_sort.py

data = [4,1,2,6,5,3]

def bigyo(num_a, num_b):
        if (data[num_b] < data[num_a]) and (num > 0):
                imsi = data[num_a]
                data[num_a] = data[num_b]
                data[num_b] = imsi
                if num_a > 0:bigyo(num_a -1, num_b -1)
for num in range(len(data)):bigyo(num -1, num)
print data

결과 입니다.

[1, 2, 3, 4, 5, 6]

def insertion(lst):
    tmp = 0
    for p in range(1,len(lst)):
        for i in range(p):
            if lst[i] > lst[p]:
                j = p
                tmp = lst[p]
                while j > i:
                    lst[j] = lst[j-1]
                    j -= 1
                lst[j] = tmp
    print lst

a = [5,2,4,6,1,3]
insertion(a)

python 3.4

rlist = [5,2,4,6,1,3]

def f1(data,index):
    while index > 0:
        if data[index] < data[index-1]:
            swap = data[index]
            data[index] = data[index-1]
            data[index - 1] = swap
        index = index - 1
    return data

def maker(data):
    index = 1
    result = []
    while index < len(data):
        result = f1(data, index)
        index += 1
    return result

print(maker(rlist))

Python 2.7

def insertionSort(vec):
    for i in range(1,len(vec)):
        for j in range(len(vec[:i])):
            if vec[i] < vec[j]:
                vec.insert(j,vec.pop(i))
                break
vec = [4,1,2,6,5,3]
insertionSort(vec)
print vec

  1 #/usr/bin/evn python
  2
  3 def insertNum(num):
  4     list = []
  5
  6     for i in range(len(num)):
  7         tem = 0
  8         if i == 0: list.insert(i, num[i])
  9         else:
 10             for j in range(i):
 11                 if ( list[tem] > num[i] ) :
 12                     list.insert(tem, num[i]); break;
 13                 else :
 14                     if (j == i-1) : list.insert(i, num[i])
 15
 16                 tem = tem + 1
 17
 18     return list
 19
 20
 21 a = [5,4,3,2,1]
 22 b = [5,2,4,6,1,3]
 23 c = [1,7,3,5,4]
 24 print insertNum(a)
 25 print insertNum(b)
 26 print insertNum(c)

결과입니다.

[1, 2, 3, 4, 5]

[1, 2, 3, 4, 5, 6]

[1, 3, 4, 5, 7]

설명

1. 리스트를 하나 만들어서 , 첫 값은 무조건 넣고.

2. 두번째 값 부터는 리스트에 들어있는 값들과 비교하여 그것보다 작은 값이면 그 앞에 넣어주는 것입니다.

def insertion_sort(test_list):
    print test_list
    for i in range(1,len(test_list)):
        j = i
        while j > 0 and test_list[j-1] > test_list[j]:
            temp = test_list[j]
            test_list[j] = test_list[j-1]
            test_list[j-1] = temp
            j = j - 1
        print test_list
    return test_list

test_list = [5,2,4,6,1,3]

insertion_sort(test_list)

// 언어 : Swift
import Foundation

class InsertionSort
{
    var index = 0; // 배열 첨자 2~5까지 변함
    var current = 0; // 비교당할 원소 저장
    var result: [Int] = []; // 배열

    init(ar0:Int, ar1:Int, ar2:Int,
        ar3:Int, ar4:Int, ar5:Int){
            self.result.append(ar0);
            self.result.append(ar1);
            self.result.append(ar2);
            self.result.append(ar3);
            self.result.append(ar4);
            self.result.append(ar5);

            for i in self.result
            {print("[\(i)]");};println("\n");
    } // 초기화

    func pullArray(stopAt:Int)
    { // 현재인덱스( 비교당하고있는 원소의 첨자 )부터
        // 새로 끼어들 자리까지 하나씩 뒤로 밀어서 저장
        var x = self.index;
        while x > stopAt
        {
            self.result[x] = self.result[x-1];
            x--;
        }
        self.result[stopAt] = self.current;
        // 새로운 자리에 자료 넣기
    }

    func compareData(cIndex:Int) -> Bool
    {
        if cIndex == 0 { return true; }

        if self.current > result[cIndex-1]{
            return true;
        }
        return false;
    } // 이전 인덱스의 자료보다 크면 참 반환

    func execloop()
    {
        var y = 0;

        // 1 ~ 마지막 인덱스까지 반복
        for index in 1...self.result.count-1
        {
            self.current = self.result[index]; // 위치결정전의 값
            self.index = index; // 1 ~ 마지막 자료까지 차례로 위치 설정
            for y=index; y>=0; y--
            { // 현재 인덱스부터 맨처음까지 줄여가며 비교
                if self.compareData(y)
                {
                    break;
                } // 이전 인덱스의 자료가 더 크면 비교를 멈춘다.
            }
             self.pullArray(y);
            // y는 새로운 자료가 들어갈 값, 그러므로 그 전까지의
            // 원소를 모두 하나씩 뒤로 밀기.

            self.printAr() // 배열 원소 출력
        }
    }

    func printAr()
    {
        for i in 0...self.index
        {
            print("[\(self.result[i])]");
        };println();
    }
}
// End of Class

    var ar = InsertionSort(ar0:5, ar1:2, ar2:4,
        ar3:6, ar4:1, ar5:3);

    ar.execloop();

JAVA입니다.

import java.util.ArrayList;

public class InsertionSort {
    public static void main(String[] args) {
        int[] numbers = new int[]{5,2,4,6,1,3};
        Sort(numbers);
    }

    public static void Sort(int[] numbers) {
        int[] tempArray = numbers;

        for (int leftV = 1; leftV < tempArray.length; leftV++) {
            for (int rightV = 0; rightV < leftV; rightV++) {
                int tempValue = 0;
                if (tempArray[rightV] > tempArray[leftV]) {
                    tempValue = tempArray[rightV];
                    tempArray[rightV] = tempArray[leftV];
                    tempArray[leftV] = tempValue;
                }
            }
        }

        for (int i = 0; i < tempArray.length; i++) {
            System.out.println(tempArray[i]);
        }
    }
}

자바입니다~

package my_test;
import java.util.Arrays;
public class T {
    public static void main(String[] args) {
        int[] arr={6,5,4,3,2,1};
        insert(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void insert(int[] arr){
        int temp=0;
        for(int i=1;i<arr.length;i++){
            for(int j=i;0<j;j--){
                if(arr[j]<arr[j-1]){
                    temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }
}

파이썬 3.4 입니다.

def num_sort(data):
    result = [data[0]]
    for x in range(1,len(data)):
        temp = data[x]
        if temp > max(result):
            result.append(temp)
        else:
            for y in range(len(result)):
                if temp < result[y]:
                    result.insert(y,temp)
                    break
    return result

// C# 입니다.
using System;

class Program
{
    static int[] numbers = new int[] { 5, 2, 4, 6, 1, 3 };

    static void Main()
    {
        for (var i = 1; i < numbers.Length; i++)
        {
            for (var k = i; k > 0; k--)
            {
                if (numbers[k - 1] > numbers[k])
                {
                    SwitchValue(numbers, k-1, k);
                }
            }
        }
        foreach (var aNumber in numbers)
        {
            Console.Write(aNumber + "  ");
        }
        Console.WriteLine("");
    }

    static void SwitchValue(int[] array, int first, int second)
    {
        int temp = array[first];
        array[first] = array[second];
        array[second] = temp;
    }
}

array = [5,2,4,6,1,3]

for i in range(1,6):
    marker = i
    for j in range(0,i):
        if array[i]<array[j]:
            marker = j
            break
    temp = array[i]
    for k in range(i,marker-1,-1):
        array[k] = array[k-1]
    array[marker]=temp

print array

import java.util.Arrays;


public class InsertionSortMain {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        insertionSort(new int[]{5,2,4,6,1,3});
    }

    private static void insertionSort(int[] is) {
        // TODO Auto-generated method stub
        for (int i = 1; i < is.length; i++) {
            for (int j = 0; j < i; j++) {
                if (is[i] < is[j]) {
                    int tmp = is[j];
                    is[j] = is[i];
                    is[i] = tmp;
                }
            }
        }

        System.out.println(Arrays.toString(is));
    }
}

파이썬입니다.

## insertion sort

def insertionSort(iterable):
    result = list(iterable)
    for i in range(1,len(result)):
        c = i
        while c > 0 and result[c-1] > result[c]:
            result[c-1], result[c] = result[c], result[c-1]
            c -= 1
    return result

print insertionSort([4,2,5,6,7,9,2,8])
print insertionSort("helloworld")

몇 시간을 고뇌한 끝에 만들었어요. 리스트 관련 함수들 사용안하고 풀이하려고 노력했습니다. 최적화 까지는 못했습니다.

# -*- coding: utf-8 -*- 
import unittest

def insertionSort(l):
  length = len(l)

  for i in range(1,length):
    ll = l[:] # l 리스트와 동일한 리스트를 만듦 
    p = i 
    # 왼쪽으로 들어갈 자리 p를 왼쪽으로 한칸씩 이동해 찾음
    # p !=0 조건은 l[i] < i[0]이 참인 경우 p = -1 가 될 수 있기 때문 
    while l[i] < l[p-1] and p != 0 :    
      p = p - 1 

    # 왼쪽 자리에서 p를 찾은 경우 
    if i != p : 
      l[p] = l[i] # p 자리에 i값을 넣음 

      # p+1 부터 i까지 오른쪽으로 한칸씩 이동시킴 
      for j in range(p, i): 
        l[j+1] = ll[j] 

  return l

class Test(unittest.TestCase):
  def test(self):
    self.assertEqual([1,2,3,4,5,6],insertionSort([5,2,4,6,1,3]))
    self.assertEqual([1,2,3,4,5,6],insertionSort([4,2,5,6,1,3]))
    self.assertEqual([1,2,3,4,5,6],insertionSort([6,2,5,4,1,3]))
    self.assertEqual([1,2,3,4,5,6],insertionSort([3,2,5,4,1,6]))
    self.assertEqual([1,2,3,4,5,6],insertionSort([3,2,4,1,5,6]))
    self.assertEqual([1,2,3,4,5,6],insertionSort([1,2,3,4,5,6]))
    self.assertEqual([1,2,3,4,5,6],insertionSort([1,2,4,3,5,6]))

if __name__ == "__main__":
  unittest.main()

Perl

@a=(5,2,4,6,1,3);
for(1..$#a){
    for(my $d=$_;$d>0;$d--){
        last if $a[$d]>=$a[$d-1];
        $a[$d]  =$a[$d]^$a[$d-1];
        $a[$d-1]=$a[$d]^$a[$d-1];
        $a[$d]  =$a[$d]^$a[$d-1];
    }
}

Python

target = [5,2,4,6,1,3]

# 하나 작은 만큼 리스트를 반복함
for index in xrange(len(target)-1):
    # print(index)
    # print(target)
    # 현재 인덱스 값과 다음 값을 비교하기 위한 인덱스
    add_index = index+1
    # 다음값과 비교해서 다음값이 작을때
    if (target[index] > target[add_index]):
        # 지나온 이전 인젝스를 다시 반복하면서
        for inner_index in xrange(add_index):
            # print('target[inner_index] = '+str(target[inner_index]) + ' target[index] = '+str(target[add_index]))
            # 값이 작으면 swap
            if (target[inner_index] > target[add_index]):
                temp = target[add_index]
                target[add_index] = target[inner_index]
                target[inner_index] = temp
                continue

print(target)

def insert_sort(list):
    for i in range(1,len(list)):
        while i > 0:
            if list[i] < list[i-1]:
                list[i],list[i-1] = list[i-1],list[i]
                i = i - 1
            else:
                i = 0
    print(list)

def main():
    list = [5,2,4,6,1,3]
    print(list)
    insert_sort(list)

if __name__ =='__main__':
    main()

package insertion_sort;

public class insertionsort {
    public static void main(String[] args)
    {
        int array[] = {5,2,4,6,1,3};
        int temp, compare_index;

        for(int i=1; i<array.length; i++){
            temp = array[i];        //옮길애 temp로 저장해둠
            compare_index = i-1;    //앞에 비교될 애들(정렬된 상태)

            //옮길애 바로 앞에부터 맨앞까지 계속 비교하여 temp보다 큰애들은 다 하나씩 뒤로 밀어둠
            while( (compare_index>=0) && array[compare_index]>temp ){
                array[compare_index+1] = array[compare_index];
                compare_index--;
            }   //다 끝나면 temp가 들어갈 자리 바로앞을 가리키니까 1칸 뒤에 temp삽입
            array[compare_index+1] = temp;

            //변화 과정마다 출력
            for(int a=0; a<array.length; a++){
                System.out.print(array[a]);
            }
            System.out.println();
        }
    }
}

public class CD443 {

    public static void main(String[] args){
        int[] array = {5,2,4,6,1,3};
        int[] sort = new CD443().sort(array);
        for (int i = 0; i < sort.length; i++) {
            System.out.println(sort[i]);
        }
    }

    private int[] sort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            for (int j = 0; j < i; j++) {
                if(array[i] < array[j]){
                    int temp = array[i];
                    for(int k = i; k >j; k--){
                        array[k] = array[k-1];
                    }
                    array[j] = temp;
                    break;
                }
            }
        }
        return array;
    }
}

c입니다.

#include <stdio.h>

int main(void){


    int arr[] = {5,2,4,6,1,3};
    int q,temp;

    for(q = 1;q <= sizeof(arr)/4-1;q++){

        if(arr[q] < arr[q-1]){

            temp = arr[q];
            arr[q] = arr[q-1];
            arr[q-1] = temp;
            q -= 2;

        }
    }

}

def insertion_sort(a):
    idx=1
    while idx<len(a):
        for k in range(idx,0,-1):
            if a[k-1] > a[k]:
                a[k],a[k-1]=a[k-1],a[k]
        idx+=1
    print(a)

if __name__ == "__main__":
    a = [5,2,4,6,1,3,8,10,7]
    insertion_sort(a)

Swift로 작성하였습니다.

import Foundation

func insertionSort(sArray: [Int]) -> [Int] {
  var arr = sArray
  for (index, value) in enumerate(arr) {
    if index == 0 { continue }
    var i = index - 1
    while(i >= 0 && arr[i] > value ) {
      (arr[i], arr[i+1]) = (arr[i+1], arr[i])
      i--
    }
  }

  return arr
}

let array = [3, 7, 2, 5, 1, 4]

println(insertionSort(array))

c 언어로 작성했습니다.

#include <stdio.h>

int main(void)
{
    int inputNum[20], i = 0, j = 0, m = 0, n = 0, p = 0;

    printf("총 몇 개의 수를 sort 할 것인가?");
    scanf("%d", &p);

    for(i = 0; i < p; i++)
    {
        printf("입력: ");
        scanf("%d", &inputNum[i]);
    }

    for(j = 0; j < p - 1; j++)
    {
        n = j;
        for(; inputNum[j] > inputNum[j + 1]; j--)
        {
            m = inputNum[j + 1];
            if(inputNum[j + 1] < inputNum[j])
            {
                inputNum[j + 1] = inputNum[j];
                inputNum[j] = m;
            }
        }
        j = n;
    }
    printf("배열 요소의 출력: ");

    for(i = 0; i < p; i++)
    {
        printf("%d ", inputNum[i]);
    }

    return 0;
}

#include <iostream>

using namespace std;

int main(int argc, char* argv[]){
    int ary[]={5,2,4,6,1,3};
    int size=sizeof(ary)/sizeof(ary[0]);

    for(int i=0;i<size;i++)
        cout << ary[i] << " ";
    cout << endl;

    for(i=0;i<size;i++)
        for(int j=i+1;j<size;j++)
            if(ary[j]<ary[i]){
                int temp=ary[i];
                ary[i] = ary[j];
                ary[j] = temp;
            }

    for(i=0;i<size;i++)
        cout << ary[i] << " ";
    cout << endl;

    return 0;
}

결과는 잘 나오는데 알고리즘 구현이 재대로 된건지.... Javascript 입니다.

var insertionSort = function(arr) {
    var tmp;
    for(var i=1;i<arr.length;i++) {
        for(var j=0;j<i;j++) {
            if(arr[i]<arr[j]) {
                tmp = arr[i];
                arr[i] = arr[j]
                arr[j] = tmp;
            }
        }
    }
    return arr;
}
insertionSort([5,1,7,2,6,10,3]);

#443.py
# insert one number to a sorted list
def add_one(numbers,num):
    new_numbers=numbers[:]
    for i in range(len(numbers)-1):
        if numbers[i]<=num and num<numbers[i+1]:
            new_numbers.insert(i+1,num)
            return new_numbers
    if numbers[0]>num:
        new_numbers.insert(0,num)
        return new_numbers
    else:
        new_numbers.insert(len(numbers),num)
        return new_numbers

def insertion_sort(numbers):
    new_numbers=numbers[:]
    for i in range(1,len(numbers)):
        new_numbers[:i+1]=add_one(new_numbers[:i],new_numbers[i])
    return new_numbers

print insertion_sort([1,3,42,4,74,5,-1,50,50,50,50,50])

C로 풀었습니다.

int arr[]={5,2,4,6,1,3};
    int i, j, temp;

    for(i=1;i<sizeof(arr)/sizeof(int); i++)
        for(j=0; j<i; j++){
            if(arr[j]>arr[i]){
                temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }

Python 2.7 / unittest / logging

import unittest
import logging

logging.basicConfig(level=logging.INFO)

lst = [5, 2, 4, 6, 1, 3]

logging.info(lst)
print "-----------"
for i in range(1, len(lst)):
    target = lst[i]
    for j in range(i-1, -1, -1):
        if lst[j] > target:
            idx = lst.index(target)
            lst[idx], lst[j] = lst[j], target
    logging.info(lst)


class TestInsertionSortList(unittest.TestCase):
    def test_equal(self):
        self.assertEqual(lst, [1, 2, 3, 4, 5, 6])

if __name__ == '__main__':
    unittest.main()

C#으로 작성했습니다.

using System.Collections.Generic;

        public static void InsertionSort(List<int> inputs)
        {
            for (int i = 1; i < inputs.Count; i++)
            { 
                for (int j = i; j > 0; j--)
                {
                    if (inputs[j] < inputs[j - 1])
                    {
                        var temp = inputs[j];
                        inputs[j] = inputs[j - 1];
                        inputs[j - 1] = temp;
                    }
                    else break;
                }
            }
        }

void main() {
    int arr[6] = {5, 2, 4, 6, 1, 3};
    int index, jindex, temp;
    for(index = 1; index < 6; index++) {
        for(jindex = 0; jindex < index; jindex++) {
            if(arr[index] < arr[jindex]) {
                temp = arr[index];
                arr[index] = arr[jindex];
                arr[jindex] = temp;
            }
        }
    }
    for(index = 0; index < 6; index++) {
        printf("%d ", arr[index]);
    }
    puts("");
}

python

num = [5,2,4,6,1,3,9,8,7,10,15,14,12,13,11]
for i in range(1, len(num)):
    for j in range(i):
        while num[i] < num[j]: num[i], num[j] = num[j], num[i]
print(num)

public static void InsertSort(ref int[] Arr)
        {

            for (int i = 1; i < Arr.Length; i++)
            {
                int Temp = Arr[i];
                int cnt = i - 1;

                while (cnt >= 0 && Arr[cnt] > Temp)
                {
                    Arr[cnt + 1] = Arr[cnt];
                    cnt--;
                }

                Arr[cnt + 1] = Temp;
            }

        }

        public static void Print(int[] Arr)
        {
            for (int i = 0; i < Arr.Length; i++)
            {
                Console.Write("{0} ",Arr[i]);
            }

            Console.WriteLine();
        }

#include<stdio.h>

int main() {
    int a[6] = { 5, 2, 4, 6, 1, 3};
    int i, j, max=0;
    for(i=0; i<6; i++){
        for(j=i; j<6; j++){
            if(a[i]>a[j]){
                max = a[i]; // 수 교환
                a[i] = a[j]; //
                a[j] = max;
            }
        }
    }
    for(i=0;i<6;i++){
        printf("%d", a[i]);
    }
    return 0;
}

자바

배열arr를 선언하고 배열간의 이동을위해 임시공간인 temp를 선언후 2중 반복문을 사용하여 뒤에잇는 숫자가 더크면 위치를 서로 바꾸는식으로 짯습니다

package dojavn;
public class dsa {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []arr={5,2,4,6,1,3};
        int temp;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<i;j++){
                if(arr[i]<arr[j]){
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }

        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

}

C언어로 작성했습니다.

#include <stdio.h>

int main()
{
    int ary[] = { 5, 2, 4, 6, 1, 3 };
    int i, j, tmp;

    for (i = 0; i < 5; i++)
    {
        if (ary[i] > ary[i + 1])
        {
            for (j = i; j >= 0; j--)
            {
                tmp = ary[j + 1];
                ary[j + 1] = ary[j];
                ary[j] = tmp;

                if (ary[j] > ary[j - 1])
                    break;
            }           
        }
    }

    for (i = 0; i < 6; i++)
    {
        printf("%d ", ary[i]);
    }

    return 0;
}

    static void exce56()
    {
        int[] arr = {5,2,4,6,1,3};

        for(int i=1;i<arr.length;i++)
        {
            for(int j=0;j<i;j++)
            {
                if(arr[j] > arr[i])
                {
                    int temp = arr[i];
                    for(int k = i-1;k>=j;k--)
                        arr[k+1] = arr[k];
                    arr[j] = temp;
                }
            }
        }

        for(int i=0;i<arr.length;i++)
            System.out.printf("%d ",arr[i]);
    }

package test;

import java.util.Arrays;

public class InsertionSort {

    private int[] array = new int[]{5,2,4,6,1,3};

    public void InsertSort(){
        for(int index = 1; index<array.length; index++){
            int temp = array[index];
            int aux = index - 1;

            while(aux>=0 && temp < array[aux]){
                array[aux + 1] = array[aux];
                aux--;
            }
            array[aux+1] = temp;
            System.out.println("changing..."+Arrays.toString(array));
        }
        System.out.println("finally ..."+Arrays.toString(array));




    }

index = [5,2,4,6,1,3,7,9,8]

def swap(num,num2):
    temp = index[num]
    index[num] = index[num2]
    index[num2] = temp

for i in range(len(index)):
    for n in range(i):
        if index[i] < index[n] :
            swap(i,n)

print(index)

#include <stdio.h>


int swapp (int list[]);


int main(void)
{
    int list[6] = {5, 2, 4, 6, 1, 3};
    swapp(list); /* Once after I declared an array, if I weant to put the array as an argument for custom function, just its name is only needed. */


    return 0;
}



int swapp (int list[])
{
    int i;
    for(i = 1; i < 6; i++)
    {
        int j;
        for(j = i; j > 0; j--)
        {
            if(list[j] < list[j-1])
            {
                int tmp;
                tmp = list[j-1];
                list[j-1] = list[j];
                list[j] = tmp;
            }
        }
    }

    int lt;
    printf("The sorted array is: [");
    for (lt = 0; lt < 6; lt++)
    {
        printf("%d, ", list[lt]);
    }
    printf("] \n");
}

C로 작성했습니다. 배열의 길이를 임의로 입력한 값에 따라 늘리는 법에 대해서는 좀 더 공부해서 보완할게요!

#include <iostream>

using std::cout;
using std::endl;

void sort(int* array, int num) {
    for ( int i = num ; i > 0 ; i -- ) {        

        // [(현재 위치 - 1) > 현재위치] 조건이 성립할 때마다 현재위치를 옮겨 가며 비교
        if ( array[i - 1] > array[i] ) {
            int temp = array[i-1];
            array[i-1] = array[i];
            array[i] = temp;
        }
    }
}

int main(void) {
    int arr[] = { 5, 2, 4, 6, 1, 3 };   // 배열선언

    int size = sizeof(arr) / sizeof(int);   // 배열크기 

    for ( int i = 1 ; i < size ; i ++ ) {
        sort(arr, i);       // 정렬
    }

    cout<<"result : ";

    for ( int j = 0 ; j < size ; j++ ) {
        cout<<arr[j]<<" ";
    }
    cout<<endl;
}

퀵소트

include

using namespace std;

void swap(int a, int b) { int tmp = a; b = a; a = tmp;

}

int main() { //대략적 알고리즘 //1.피봇 인덱스 설정한다

//2.피봇보다 작은 인덱스를 가진것들과 비교한뒤

//3.크다면 자리바꿈,작다면 제자리에둔다.

//4.비교인덱스는 피봇인덱스 직전까지 비교한다.


int Array[6] = { 5, 2, 4, 6, 1, 3 };
int pivot_intdex;
int compare_index;

cout << "정렬 전=";
for (int i = 0; i < 6; i++)
{
    cout <<"  "<< Array[i];
}
cout << endl << endl;


for (pivot_intdex = 2; pivot_intdex < 6; ++pivot_intdex)
{
    for (compare_index = 0; compare_index < pivot_intdex - 1; ++compare_index)
    {

        if (Array[pivot_intdex] < Array[compare_index])
        {
            swap(Array[pivot_intdex], Array[compare_index]);
        }

    }

}

cout <<endl<< "정렬후=" ;
for (int i = 0; i < 6; i++)
{
    cout <<" "<< Array[i];
}

}

def insertion_sort(arr):
    for i in range(1, len(arr)):
        for j in range(i, 0, -1):
            while arr[j] < arr[j - 1]:
                arr[j - 1], arr[j] = arr[j], arr[j - 1]

파이썬입니다.

def insertionSort(l):
    for i in range(1,len(l)):
        for j in range(i):
            if l[i] < l[j]:
                l.insert(j, l[i])
                l.pop(i+1)
                break
    return l

inputList = [5, 2, 4, 6, 1, 3]
print(insertionSort(inputList))

<?php
    $arr = array(5, 2, 4, 6, 1, 3);

    for ($i=1;$i<count($arr);$i++) {
        for($j=$i;$j>0;$j--){
            if($arr[$j] <= $arr[$j-1]) {
                $temp = $arr[$j-1];
                $arr[$j-1] = $arr[$j];
                $arr[$j] = $temp;
            }
        }
    }

    print_r($arr);
?>

#include <stdio.h>
int main(void){
        int n,i,j,a,b;
        printf("배열의 크기를 입력하시오:");
        scanf("%d",&n);
        int  arr[n];
        for(i=0;i<n;i++){
                printf("arr[%d]번째 배열입력:",i);
                scanf("%d",&arr[i]);
        }
        for(i=1;i<n;i++){
                for(j=0;j<i;j++){
                        if(arr[i]<arr[j]){
                                a=arr[i];
                                for(b=(i-1);b>=j;b--){
                                        arr[b+1]=arr[b];
                                }
                                arr[j]=a;
                        }
                }
        }
        for(i=0;i<n;i++){
                printf("%3d",arr[i]);
        }
        printf("\n");
        return 0;
}

배열의 크기와 배열에 들어갈숫자를 직접 입력하도록 했습니다

파이썬 2.7

def insertion_sort(l):
    for i in range(len(l)):
        for j in range(i):
            if l[i] < l[j]:
                l[i], l[j] = l[j], l[i]
    return l


l = [5,2,4,6,1,3]

print insertion_sort(l)

t0 = [5,2,4,6,1,3]
for i in range( 1, len(t0) ):
    for j in range( i ):
        while t0[i] < t0[j]:
            t0[i], t0[j] = t0[j], t0[i]
print(t0

t0 = [5,2,4,6,1,3]
for i in range( 1, len(t0) ):
    for j in range( i ):
        while t0[i] < t0[j]:
            t0[i], t0[j] = t0[j], t0[i]
print(t0)

a = [5,2,4,6,1,3] for i in range( 1, len(a) ): for j in range( i ): while a[i] < a[j]: a[i], a[j] = a[j], a[i] print(a)

삽입속도를 올리는데 주력했습니다.

def insertion_sort(l):
    if len(l)==1: return
    for i in range(1,len(l)):
        if l[i]>=l[i-1]:continue
        if l[i]<=l[0]:l.insert(0,l.pop(i));continue
        tmp = l.pop(i)
        left = 0
        right = i-1
        while 1:
            middle=(left+right+1)/2
            if l[middle-1]<=tmp<=l[middle]:l.insert(middle,tmp);break
            elif tmp < l[middle-1] :right=middle-1
            else : left=middle

Ruby

Recursion way

swap = ->a,s { a[s],a[s-1]=a[s-1],a[s]; a }
trav = ->a,s { s==0? a : (a[s]<a[s-1]? trav[swap[a,s],s-1] : a) }
sort = ->a,s=1 { a.size>s ? sort[trav[a,s],s+1] : a }
p sort.([5,2,4,6,1,3]) #=> [1,2,3,4,5,6]

Test

expect(sort.([5,2,4,6,1,3])).to eq [1,2,3,4,5,6]
# depdent function
expect(swap.([5,2,4,6,1,3],1)).to eq [2,5,4,6,1,3]
expect(trav.([5,2,4,6,1,3],1)).to eq [2,5,4,6,1,3]
expect(trav.([1,2,4,5,6,3],5)).to eq [1,2,3,4,5,6]

while __name__ == '__main__':
    inpt = eval('['+input('a,b,c,d 형식으로 공백없이 입력: ')+']')
    for x in range(1, len(inpt)):
        for y in range(x):
            if y == 0 and inpt[x]<inpt[y]:tmp = inpt.pop(x);inpt = [tmp]+inpt[:];print(inpt)
            if inpt[y]<inpt[x]<inpt[y+1]:tmp = inpt.pop(x);inpt[y+1:] = [tmp]+inpt[y+1:];print(inpt)

파이썬 3.5.1입니다.

def sorting(*args) :
    array = list(args) 

    for i in range(1,len(array)) :

        for j in range(0,i) :

            if (array[j] > array[i]) :              
                temp = [-1 for k in range(j,i)]
                temp = array[j:i]
                array[j] = array [i]
                array[j+1:i+1] = temp
                break

    return array

package com.company;

/**
 * Created by seohyeyeong on 4/15/16.
 */
public class DataStructure {
    int array[];
    int result[];
    public DataStructure(int array[] ){
        this.array = array;
        result = array.clone();
    }
    public void sort(){
        int temp = 0 ;
        for(int i = 1 ; i < array.length ;i++){
            for(int j = 0; j < i ; j++){
                if(array[i] < array[j]){
                    insert(i,j);

                }

            }
            print();

        }

    }

    public void insert(int i, int j){
        int temp  = array[i];
        int temp2= 0;
        for(int k = i-1 ; k >= j  ; k--){
            temp2 = array[k];
            array[k+1] = temp2;
        }
        array[j]= temp;
        print();

    }


    public void print(){
        for(int i = 0  ; i < array.length ;i++){
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

#include <stdio.h>

void push( int *arr[], int a, int b)
{
    int i;
    for(i=0;i<b-a+1;i++)
    {
        *arr[b+1-i] = *arr[b-i];
    }
}


int position(int *parr[], int a)
{
    int i;
    if (*parr[0]> *parr[a])
    {
        return 0;
    }
    else
    {
        for(i=1;i<a;i++)
        {
            if(*parr[i]>*parr[a] && *parr[i-1]<*parr[a])
            {
                return i;
            }
        }
    }
    return a;
}


int main(void)
{
    int arr[10] = {5,4,6,7,2,9,8,0,1,3};
    int i;
    int j;
    int pstn;
    int *parr[10];
    int temp;
    for(i=0;i<10;i++)
    {
        parr[i] = &arr[i];
    }
    for(i=1;i<10;i++)
    {
        pstn = position(parr,i);
        if (pstn == i)
        {
            ;
        }
        else
        {
            temp = *parr[i];
            push(parr, pstn, i-1);
            *parr[pstn] = temp;
        }
    }
    for(j=0;j<10;j++)
    {
        printf("%d", *parr[j]);
    }
    return 0;
}

C 에요. 너무 기뻐요!!!!!

def sort(a):
    i=1

    while i!=len(a):
        j=i
        if a[i]<a[i-1]:
            a[i-1],a[i]=a[i],a[i-1]
            print(a)
            for k in range(1,j):
                if a[j-k]<a[j-k-1]:
                    a[j-k],a[j-1-k]=a[j-1-k],a[j-k]
                    print(a)

        i=i+1
    return a


a=[5,2,4,6,1,3]
print(sort(a))

Python 3.4.4

def insert_sort(target):
    for i in range(1, len(target)):
        for j in range(i):
            if target[j] > target[i]:
                target.insert(j, target.pop(i))
                break
    return target

print(insert_sort([5, 2, 4, 6, 1, 3]))

C++을 이용한 Insertion Sort program입니다.

#include <iostream> 
#include <cstdio> 
#include <vector> 
#include <algorithm> 
using namespace std; 

void insertionSort(vector<int> &A){
    for (int i = 0; i < A.size(); i++){
        int j = i;  
        while (j > 0 && A[j-1] > A[j]){
            swap(A[j-1],A[j]); 
            j--;  
        }
    }
}

int main(){
    vector<int> A;  
    A.push_back(5);A.push_back(2);A.push_back(4);A.push_back(6);  
    A.push_back(1);A.push_back(3); 
    insertionSort(A); 
    for (int i = 0; i < A.size(); i++){
        printf("%d ",A[i]); 
    }
    printf("\n"); 
    return 0; 
}

import collections

x = [5,2,4,6,1,3]
def inssort(x):
    for i in range(1,len(x)):
        for j in range(0,i):
            [x[j],x[i]] = collections.minmax(x[j],x[i])
        print(x)    

inssort(x)

minmix함수는 양자간 최솟값과 최댓값을 list object로 반환하는 함수입니다.

늅늅입니다. 자바로 시도해 봤는데;;;; 문제를 잘못 이해한건지... 결과 값은 정상적으로 나와서 맞은건지 틀린건지 잘 모르겠네요;;

public static int[] Numbers;
    public static void main(String args[])
    {
        Numbers = new int[]{5,2,4,6,1,3};

        InsertionSorting(Numbers);

    }

    public static void InsertionSorting(int[] number)
    {
        for(int i = 1; i < number.length; i++ )
        {
            for(int j = 0; j < i; j++)
            {
                if(number[j] > number[i])
                {
                    int tempNum = number[j];
                    number[j] = number[i];
                    number[i] = tempNum;
                }
                else 
                {
                    continue;
                }
            }
        }

        for(int i = 0; i < number.length; i++)
        {
            System.out.print(String.valueOf(number[i] + " "));
        }
    }

python 2.7

def Insertion_Sort(L):
    Max=1
    index=1
    while(index<len(L)):
        for i in range(0,Max+1):
            if(L[index]<L[i]):
                L[index],L[i] = L[i],L[index]

        index+=1
        Max+=1

Insertion_Sort([5,2,4,6,1,3])

namespace ConsoleApplication6
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 5, 2, 4, 6, 1, 3 };
            InsertionSort(arr);
        }

        static void InsertionSort(int [] _arr)
        {
            int sortIndex;

            for(int i  = 1; i < _arr.Length; i++)
            {
                sortIndex = i;
                for(int j = i-1; j >= 0; j--)
                {
                    if(_arr[sortIndex] < _arr[j])
                    {
                        int temp = _arr[sortIndex];
                        _arr[sortIndex] = _arr[j];
                        _arr[j] = temp;
                        sortIndex = j;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
    }
}

Python 코드입니다

inp = [5,2,4,6,1,3]

for i in range(1,len(inp)):
    for j in range(i):
        inp[i],inp[j] = max(inp[i],inp[j]), min(inp[i],inp[j])
        print(inp, i ,j)

print(inp)

파이썬 초보입니다. 많은 피드백 부탁드립니다!

def insertion_sort(list_):
    for i in range(1, len(list_)):
        for j in range(0, i):
            if list_[j] > list_[i]:
                tmp = list_[i]
                del list_[i]
                list_.insert(j, tmp)
                break
    return list_
print(insertion_sort([5,2,4,6,1,3]))

Python 3.5.2에서 작성하였습니다.

arr,count = [5,2,4,6,1,3],1

while count != len(arr):
    for x in range(count,0,-1):
        if arr[x] < arr[x-1]:
            arr.insert(x-1,arr.pop(x))
    count += 1
print(arr)

#### 2016.12.15 D-434 ####

import java.util.Arrays;

public class InsertionSort {
    public static void main(String[] args) {
        int[] numbers=new int[]{5,2,4,6,1,3};

        for(int i=1;i<numbers.length;i++){
             int temp = numbers[i];
             for(int j=i; j > 0; j--){
                 if(numbers[j-1] > temp){
                     numbers[j] = numbers[j-1];
                     if(j==1){
                         numbers[j-1] = temp;
                         break;
                     }
                 } else {
                     numbers[j] = temp;
                     break;
                 }
             }
             System.out.println("sorting... "+Arrays.toString(numbers) );
         }
         System.out.println("finally... "+Arrays.toString(numbers));
    }
}

C(ANSI)

gcc -ansi -pedantic-errors -W -Wall

#include <stdio.h>

void InsertionSort(int * arr, int size);

int main(void)
{
    int i;
    int arr[6] = {5, 2, 4, 6, 1, 3};    
    InsertionSort(arr, 6);

    for (i = 0; i < 6; i++)
        printf("%d ", arr[i]);
    putchar('\n');

    return 0;
}

void InsertionSort(int * arr, int size)
{
    int i, j;
    int insertData;
    for (i = 1; i < size; i++)
    {
        insertData = arr[i];

        for (j = i - 1; 0 <= j; j--)
        {
            if (insertData < arr[j])
                arr[j + 1] = arr[j];

            else
                break;
        }

        arr[j + 1] = insertData;
    }
}

#include <stdio.h> 
void main(void){ 
    int n[5] = {15, 11, 1, 3, 8};
    for(int i = 1 ; i < 5  ; i++) {
        int index = i;
        for(int j = i-1  ; j >= 0  ; j--) {
            int temp;
            if(n[index] < n[j]) {
                temp = n[index];
                n[index] = n[j];
                n[j] = temp;
                index = j;
            }
        }

        printf("%d round : ", i);
        for(int j = 0 ; j<5   ; j++) 
            printf("%d ", n[j]);
        printf("\n");
    }
}

def sortt(data):
    n=len(data)
    for i in range(1,n):
        for j in range(i-1,-1,-1):
            if data[i]<data[j]:
                data[i],data[j], i,j=data[j],data[i],j, i
            else:
                break
    return data
sortt([5,2,4,6,1,3])

import java.util.Arrays;

public class InsertionSort {
    public static void main(String[] args) {
        int[] i = new int[]{5, 2, 4, 6, 1};
        insertionSort(i);
    }

    private static void insertionSort(int[] i) {
        int l = i.length;
        for (int j = 1; j < l; j++) {
            int a = i[j];
            for (int k = 0; k < j; k++) {
                if (a < i[k]) {
                    int t = a;
                    int n = k;
                    while (n < j) {
                        i[j] = i[j - 1];
                        j--;
                    }
                    i[k] = t;
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(i));
    }
}

package training;

import java.util.ArrayList;

public class InsertionSort {

public static void main(String[] args) {
    int[] arr = {5,2,4,6,1,3};
    ArrayList<Integer> arrList = new ArrayList<Integer>();      
    for(int t=0;t<arr.length;t++){
        arrList.add(arr[t]);
    }

    int iIdxNow = 0; // 현재 위치
    int iIdxAfter = 0; // 현재 수가 다음 가야할 위치

    for(int i=0;i<arr.length;i++){

        iIdxNow = i; // 현재위치 저장

        // 자기 위치보다 앞에 있는 수중에 자기수보다 작은수가 나올때까지 찾은 후 그 위치를 저장
        for(int j=0;j<=i;j++){
            if(arr[i] < arr[j]){ // 작은수가 있는 위치를 찾음
                iIdxAfter = j;
                break;
            } else if(arr[i] == arr[j]){ //  작은 수가 없을 경우 그 위치 유지
                iIdxAfter = i;                  
                break;
            }
        }

        // 자기는 그 위치로 들어가고 나머지는 한칸씩 뒤로 이동
        for(int k=0;k<arr.length;k++){ // 자기보다 작은 수를 일단 임시 배열에 넣음
            if(k < iIdxAfter){
                arrList.set(k, arr[k]);
            } else if(k > iIdxNow){
                arrList.set(k, arr[k]);
            } else if(k == iIdxAfter) {
                arrList.set(k, arr[i]);
            } else if(k > iIdxAfter){
                arrList.set(k, arr[k-1]);
            }
        }

        // 변경된 결과를 원래 배열에 입력
        for(int t=0;t<arrList.size();t++){
            arr[t] = arrList.get(t);
        }
    }

    // sorting 결과 출력
    for(int t=0;t<arrList.size();t++){
        System.out.println("arrList.get("+t+") ==> " + arrList.get(t));
    }

}

}

a=[5,2,4,6,1,3]
for i in range(len(a)):
    for k in range(len(a)):
        if a[i]<a[k]:
            a[i],a[k]=a[k],a[i]
print(a)

python 3.4 list index swap & push

a = '5 2 4 6 1 3'

def insertion_sort(data):
    sort = data.split()
    print(sort)
    for x in range(1,len(sort)):
        for a in range(len(sort)):
            if int(sort[a]) > int(sort[x]):
                sort[a],sort[a+1:x+1] = sort[x],sort[a:x]
                print(sort)
                break
    return " ".join(sort)

>>> insertion_sort(a)
['5', '2', '4', '6', '1', '3']
['2', '5', '4', '6', '1', '3']
['2', '4', '5', '6', '1', '3']
['1', '2', '4', '5', '6', '3']
['1', '2', '3', '4', '5', '6']
'1 2 3 4 5 6'

#include <iostream>

int main(void)
{
    int arr[] = {5, 2, 4, 6, 1, 3};
    int t, temp;

    for(int i = 0; i < 5; i++)
    {
        t = i + 2;
        while(arr[t--])
        {
            if(arr[t] > arr[t-1])
                break;
            else
            {
                temp = arr[t-1]; arr[t-1] = arr[t]; arr[t] = temp;          
            }
        }
    }

    for(int i = 0; i < 6 ; i++)
        std::cout << arr[i] << std::endl;

    return 0;
}

// Sort - C
#include <stdio.h>

int main(void)
{
    int target[6] = {5,2,4,6,1,3};
    int temp, i, j;
    for (i = 0; i < 6; i++)
        printf("%d", target[i]);
    printf("\n");
    for (i = 1; i < 6; i++)
    {
        for (j = 0; j < i; j++)
        {
            if (target[j] > target[i])
            {
                temp = target[j];
                target[j] = target[i];
                target[i] = temp;
            }
        }
        for (j = 0; j < 6; j++)
            printf("%d", target[j]);
        printf("\n");
    }
}
// 직접 돌려보면 과정이 나온다.

public static void main(String[] args) {
    int[] arr={5,2,4,6,1,3};
    for(int i=0;i<arr.length-1;i++){
        for(int j=i;j>=0;j--){
            int temp=compare(arr[j],arr[j+1]);
            if(arr[j]==temp){
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }else{
                break;
            }
        }
    }
}   
public static int compare(int a, int b){
    int result=(a<b)?b:a;
    return result;
}

javascript

var array = [5,2,4,6,1,3];

console.log(`step 0 : ${array.join(" ")}`);

for (let i = 1; i < array.length; i++) {
    var c = 0;

    while (array[i] > array[c]) c++;

    for (let j = c; j < i; j++) {
        var temp = array[j];
        array[j] = array[i];
        array[i] = temp;
    }

    console.log(`step ${i} : ${array.join(" ")}`);
}

def sorting(numlist) :  # type(numlist) == list
    s = numlist

    for i in range(1, len(s)) :

        if s[i] > s[i-1] :
            pass

        else :
            n = i

            while n >= 1 :

                if s[n] < s[n-1] :
                    s[n], s[n-1] = s[n-1], s[n]
                    n -= 1

                else :
                    break

            continue

    return s

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


int main(int argc,char* argv[])
{   
    int* arr = (int*)malloc(sizeof(int)*(argc-1));
    for(int i=0;i<argc-1;i++)
    {
        arr[i] = atoi(argv[i+1]);
        printf("%d ",arr[i]);
    }
    printf("\n");   
    for(int p=0;p<5;p++)
    {
        for(int i=1;i<argc-1;i++)
        {
            int tmp = 0;
            for(int j=0;j<i;j++)
            {
                if(arr[i]<arr[j])
                {
                    tmp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = tmp;
                    j=i;    
                }
            }
        }
    }
    for(int i=0;i<argc-1;i++)
        printf("%d ",arr[i]);

    return 0;
}

def insertionSort(arr):
    for idx in range(1, len(arr)):
        idx1 = idx
        while True:
            if idx1 >= 1 and arr[idx1] < arr[idx1-1]:
                arr[idx1], arr[idx1-1] = arr[idx1-1], arr[idx1]
                idx1 -= 1
            else:
                break
        print(arr)

insertionSort([5,2,4,6,1,3])

def insertion_sort(arr):
    for i in range(1, len(arr)):
        #print(arr)
        n = arr[i]
        for j in range(i, -1, -1):
            if j == 0 or arr[j - 1] <= n:
                arr[j] = n
                break

            arr[j] = arr[j - 1]

    #print(arr)
    return arr

package codingdojang;

import java.util.ArrayList;

public class ex56 {

public static void main(String[] args) {
    // TODO Auto-generated method stub


    ArrayList<Integer> num = new ArrayList<Integer>();
    num.add(5);
    num.add(2);
    num.add(4);
    num.add(6);
    num.add(1);
    num.add(3);

    int temp = 0;

    for(int i=0; i<num.size()-1; i++) {
        for(int j=i+1; j<num.size(); j++) {
            if(num.get(j) < num.get(i)) {
                temp = num.get(j);
                num.remove(j);
                num.add(i, temp);
            }
        }
    }

    for(int i=0; i<num.size(); i++) {
        System.out.print(num.get(i)+ " ");
    }

}

}

s = [5,2,4,6,1,3]
for i in range(1, len(s)):
    s = sorted(s[:i+1]) + s[i+1:] 
s

python 3.52입니다.

저는 리스트가 주어지면 두번째 숫자부터 자신의 왼쪽에 있는 수들을 leftlist로 뽑아낸 뒤, 그 list에서 해당 숫자의 위치를 지정하여 새로운 list를 뽑아내어 해당숫자까지 포함된 리스트가 원래 리스트를 지속적으로 리프레시하는 방식으로 소팅을 했습니다.

스텝별로 모두 표시가 되게 해놓았으니 확인해보시면 될겁니다.

#해당 숫자의 왼쪽에 있는 것들 리스트 만들기
def makingleftlist(i):
    leftlist = list[:i-1]
    return leftlist

#대소비교해서 본인 위치찾기 함수 만들기
def positionsetter(mylist, new_member):
    if new_member < min(mylist):
        mylist.insert(0, new_member)
    elif new_member > max(mylist):
        mylist.insert(len(mylist), new_member)
    else:
        for i in mylist:
            if i < new_member and new_member < mylist[mylist.index(i)+1]:
                mylist.insert(mylist.index(i)+1, new_member)
                break
            else:
                continue
    return mylist


list = [5,2,4,6,1,3]

for i in list[1:]:
    a = list.index(i)+1
    print('step{}'.format(a))
    print(positionsetter(makingleftlist(a),i))
    list[:a] = positionsetter(makingleftlist(a),i)
    print(list)

import java.util.Arrays;


public class InsertionSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        insertionSort(new int[]{5,2,4,6,1,3});
    }

    private static void insertionSort(int[] is) {
        // TODO Auto-generated method stub
        for (int i = 1; i < is.length; i++) {
            for (int j = 0; j < i; j++) {
                if (is[i] < is[j]) {
                    int tmp = is[j];
                    is[j] = is[i];
                    is[i] = tmp;
                }
            }
        }

        System.out.println(Arrays.toString(is));
    }
}

def sorting(A):
    count=1
    def inner(B, n):
        if len(B)==n:
            return(B)
        m=n-1
        tmp=B
        print(tmp)
        while m>=0:
            if not m and tmp[m]>tmp[n]:
                tmp=[tmp[n]]+tmp[:n]+tmp[n+1:]
                break
            elif tmp[m]<tmp[n]:
                tmp=tmp[:m+1]+[tmp[n]]+tmp[m+1:n]+tmp[n+1:]
                break
            m-=1
        return(inner(tmp, n+1))
    return(inner(A, count))

nums=[5,2,4,6,1,3]
print(sorting(nums))

lst = [5,2,4,6,1,3,4,3,7,6,3,4]
for i in range(1,len(lst)):
    for j in range(i):
        if lst[i]<=lst[j] :
            tmp = lst[i]
            lst.pop(i)
            lst.insert(j,tmp)
print(lst)

package CodingDojang;

public class InsertionSort {

    public static void insertionSort(int [] arr){
        int i, j; 
        for(i = 1; i < arr.length; i++){
            int temp = arr[i]; // 비교 대상이 되는 값을 temp에 넣는다.
            for(j = i - 1 ; j >= 0 && temp < arr[j]; j--){
            /* j는 이미 정렬된 temp 이전에 있는 값을 가리키는 index이다.
            만약 temp가 arr[j](j번째의 값)보다 작다면 sort해야할 값이므로 loop를 진행한다.
            이를 temp보다 작은값이 나타날 때까지 수행한다.*/
                arr[j+1] = arr[j]; 
            }
            arr[j+1] = temp; // loop가 끝났다는 의미는 temp보다 작은값을 찾았다는 의미이므로 j+1의 index에 temp값을 넣어준다.
        }
    }

    public static void main(String[] args) {
        int [] arr = {5, 2, 4, 6, 1, 3};
        insertionSort(arr); // InsertionSort
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        } // print
    }
}

파이썬 3.6

def sortfunc(data):
    datalist = list(data)
    for i in range(1,len(data)):
        while datalist[i] < datalist[i-1]:
            datalist.insert(i-1,datalist[i])
            del datalist[i+1]
            i -= 1
            print(''.join(datalist))
            if i== 0: break

if __name__ == "__main__":
    data = input('')
    print("\n")
    sortfunc(data)

• 결과값

524613


254613
245613
245163
241563
214563
124563
124536
124356
123456

array = [5,2,4,6,1,3]
tmp = array[:]
print array

for i in range(1,len(array)): # from second index 
    if array[i-1] > array[i]:
        if i == 1:
            tmp[0]=array[1]
            tmp[1]=array[0]
            array[:]=tmp[:]
            print array
        else:
            for j in range(i-1,-1,-1): 
                if array[j] > array[i]: 
                    ind=j
            tmp[ind]=array[i]
            tmp[ind+1:i+1]=array[ind:i]
            array[:]=tmp[:]
            print array

x <- c(5,3,8,1,2,7)
insert_sort<-function(...){
    myargs=c(...)
    for(i in 2:(NROW(myargs))){
      key<-myargs[i]
      j <- i-1
      while(j>0){
        if(key<myargs[j]){
          myargs[j+1]<-myargs[j]
          myargs[j]<-key
        }
        j<-j-1
      }
    }
    print(myargs)
}
insert_sort(x)

s <- c(5,2,4,6,1,3)
tmp <- NULL
wh <- NULL

for(i in 2:6){

    if(sum(s[1:i-1] > s[i])>0){

      tmp <- s[i]
      wh <- which(s[1:i-1] > s[i])

      s[wh+1] <- s[wh]
      s[min(wh)] <- tmp

      }
}
s

파이썬으로 작성했습니다.

mylist=[5,2,4,6,1,3,0]

for n in range(1,len(mylist)):
    sort_num=mylist[n]
    sort_index=n
    for m in range(n,-1,-1):
        if mylist[m]>sort_num:
            mylist[m+1]=mylist[m]
            sort_index=m
    mylist[sort_index]=sort_num
print(mylist)

파이썬

input1 = [5, 2, 4, 6, 1, 3]


def insertion_sort_step(i, j):
    print(i, j, ':', i[j])
    for m in range(j):
        if i[j] < i[m]:
            sort_number = i[j]
            for n in range(j, m, -1):
                i[n] = i[n-1]
            i[m] = sort_number
    return i


def insertion_sort(i, j=1):
    if j == len(i)-1:
        return insertion_sort_step(i, j)
    else:
        m = insertion_sort_step(i, j)
        j += 1
        return insertion_sort(m, j)


print(insertion_sort(input1))

def insertionsort(a):
    b = [a[0]]
    for i in range(1,len(a)):
        b.append(a[i])
        if a[i] < a[0]:
            for j in range(1, i+1):
                a[j] = b[j-1]
            a[0] = b[i]
            b[:i+1] = a[:i+1]
        elif a[i] > a[i-1]:
            pass
        else:
            for j in range(i-1):
                if a[j]<a[i] and a[i]<a[j+1]:
                    for k in range(j+1, i):
                        a[k+1] = b[k]
                    a[j+1] = b[i]
            b[:i+1] = a[:i+1]
    return a

num_str=input("숫자를 입력하세요:")   #1000개 미만
num_list=num_str.split(' ')

for k in range(1,len(num_list)):
    min_index=-1000
    for g in range(k-1,-1,-1):
        if num_list[k]<num_list[g]:
            min_index=g
    if min_index>=0:
        for_change=num_list[:min_index]+[num_list[k]]+num_list[min_index:k]+num_list[k+1:]
        num_list=for_change

print(num_list)

def sort(array) :
    for n in range(1,len(array)) :
        for m in range(0,n) :
            if array[n] > array[m] :
                continue
            else :
                array.insert(m, array[n])
                del array[n+1]
    print(array)

앞에서 알고리즘의 차이에 대해서 얘기해주셨는데, 이 코딩이 앞에서 설명해주신 'insertion-sort' 알고리즘이 맞는지 모르겠네요. else 부분 마지막에 print(array)를 통해서 순서대로 진행되는 것은 확인했습니다만, 혹시 알고리즘이 맞는지 확인해주실 수 있을까요?

[5,2,4,6,1,3] 을 넣었을때의 처리 과정입니다. [2, 5, 4, 6, 1, 3] [2, 4, 5, 6, 1, 3] [1, 2, 4, 5, 6, 3] [1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6]

def Insertion(*nums):
    result = list(nums)
    for args in result:
        if result.index(args) != 0:
            while result[result.index(args) - 1] > args and result.index(args) != 0:
                dire = result.index(args)
                result.remove(args)
                result.insert(dire - 1, args)
    return result

Python 3

"""
author: Kenny Jeon
date: 04/11/2018
Time complexity: O(n^2)
"""


def insertion_sort(li):
    unsorted = li
    for i in range(1, len(unsorted)):
        step = 0
        key = unsorted[i]
        while i > 0 and unsorted[i-1] > key:
            unsorted[i] = unsorted[i-1]
            unsorted[i-1] = key
            # swap value
            i -= 1
            step += 1
            # process
            print("key: %d, step: %d" % (key, step))
            print(unsorted)
            # print process
    return unsorted


if __name__ == "__main__":
    li = [5, 2, 4, 6, 1, 3]
    result = insertion_sort(li)
    print("sorted list: ", end='')
    print(result)

자바입니다.

public class InsertionSort {
    private static final int[] arr = new int[]{5, 2, 4, 6, 1, 3};
    public static void main(String[] args) {
        for (int i = 1; i < arr.length; i ++) {
            int compare = arr[i];
            for (int descNum = 0; descNum < i; descNum++) {
                if (compare < arr[descNum]) {
                    for (int m = i;  m > descNum;   m--) {
                        arr[m] = arr[m-1];
                    }
                    arr[descNum] = compare;
                    break;
                }

            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

#include<iostream>
using namespace std;

int main()
{
    int array[6] = { 5,2,4,6,1,3 };
    int tmp = 0;
    for (int i = 0; i < 6; i++)
    {
        for (int j = i+1; j < 6; j++)
        {
            if (array[i] > array[j])
            {
                tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    }
    for (int i = 0; i < 6; i++)
    {
        cout << array[i] << ' ';
    }
    cout << endl;
}

import java.util.Arrays;

public class InsertionSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] inputArray = {5,2,4,6,1,3};

        for(int i=1; i<inputArray.length; i++){
            int temp = inputArray[i];
            for(int j=0; j < i; j++){
                if(inputArray[j] > temp){ // 이전 인덱스 값이 더 클경우
                    for(int k = i; k > j; k--){
                        inputArray[k] = inputArray[k-1];
                    }
                    inputArray[j] = temp;
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(inputArray));
    }

}

// 자바

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //int t = Integer.parseInt(br.readLine());

        int[] nums = {5,2,4,6,1,3};

        for (int i=0; i<nums.length; i++) {
            for (int j=0; j<nums.length-1; j++) {
                if (nums[j] > nums[j+1]) {
                    int tmp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }

#Insertion Sort

def InsertionSort(input_list):
    copy_list = input_list.copy()

    # idx 값이 자신이 들어갈 곳을 찾아 insert 된다.
    for idx in range(1,len(input_list)):
        if input_list[idx] < input_list[idx-1]:
            # insert 후 앞부분만 sort 이용
                copy_list.insert(idx-1,input_list[idx])
                copy_list = sorted(copy_list[:idx+1]) + copy_list[idx+1:]

    return copy_list[:len(input_list)]

print(InsertionSort([5,4,3,2,1]))

def insertion(x):
    for i in range(1, len(x)):
        for j in range(i):
            if x[i] < x[j]:
                x = x[:j] + [x[i]] + x[j+1:i] + [x[j]] + x[i+1:]
    return x


import random
n = 10
a = list(random.sample(range(1, n+1), n))
print(a, insertion(a))

def sorted_ex (n) :
        for x in range(1,len(n)) :
            for y in range(x) :
                if n[x]<n[y] :
                    n.insert(y,n[x])
                    del n[x+1]
        return n
print(sorted_ex([5,2,4,6,1,3]))

import java.util.ArrayList;

public class InsertionSort {
    public static void main(String[] args) {
        int[] numbers = new int[]{5,2,4,6,1,3};
        Sort(numbers);
    }

    public static void Sort(int[] numbers) {
        int[] tempArray = numbers;

        for (int leftV = 1; leftV < tempArray.length; leftV++) {
            for (int rightV = 0; rightV < leftV; rightV++) {
                int tempValue = 0;
                if (tempArray[rightV] > tempArray[leftV]) {
                    tempValue = tempArray[rightV];
                    tempArray[rightV] = tempArray[leftV];
                    tempArray[leftV] = tempValue;
                }
            }
        }

        for (int i = 0; i < tempArray.length; i++) {
            System.out.println(tempArray[i]);
        }
    }
}

Swift입니다.

func sortByInsertion(_ givenNumbers: [Int]) -> [Int] {
    var numbers = givenNumbers
    let count = numbers.count 

    for startIndex in (1..<count) {
        for targetIndex in 0..<startIndex {
            if numbers[startIndex] < numbers[targetIndex] {
                numbers.insert(numbers[startIndex], at: targetIndex)
                numbers.remove(at:startIndex + 1)
                break
            }
        }
    }
    return numbers
}

print(sortByInsertion( [5,2,4,6,1,3])) 

Python

#a = [5,2,4,6,1,3]
a = [8,3,1,5,7,2,3,5,7,2]
ans = [a[0]]
for i in range(1, len(a)):
    for j in range(0, len(ans)):
        if ans[j] > a[i]:
            ans = ans[:j] + [a[i]] + ans[j:]
            break
    else:
        ans.append(a[i])
    print(ans)

파이썬~ 중간 스텝도 함께 출력해보았습니다.

list1 = [5,2,4,6,1,3]

count = 0
print(count,":",list1)
for i in range(1, len(list1)):
    for j in range(0,i):
        if list1[i] < list1[j]:
            temp = list1[i]
            list1[i] = list1[j]
            list1[j] = temp
    count += 1
    print(count,":",list1)

# Output:
# 0 : [5, 2, 4, 6, 1, 3]
# 1 : [2, 5, 4, 6, 1, 3]
# 2 : [2, 4, 5, 6, 1, 3]
# 3 : [2, 4, 5, 6, 1, 3]
# 4 : [1, 2, 4, 5, 6, 3]
# 5 : [1, 2, 3, 4, 5, 6]

파이썬 3

lst = [5,2,4,6,1,3]

def fn(list1):
    for i in range(1, len(list1)):
        for j in range(i):
            if list1[i] < list1[j]:
                list1.insert(j,list1[i])
                del list1[i+1]
                break
    return list1

print(fn(lst))

def insertion_sort(arr):
    for i in range(1,len(arr)):
        for j in range(i):
            if arr[j] > arr[i]:
                arr.insert(j, arr.pop(i))
                break
    return arr

print(insertion_sort([5,2,4,6,1,3]))

list = [9,8,7,6,5,4,3,2,1]

for i in range(1,len(list)):
    print(list[i])
    f = list[i]
    j = i
    while j != 0:
        j = j - 1
        #print(' '+str(list[j]))
        k = list[j]
        if f < k:
            list[j] = f
            list[i] = k 
        i = i - 1
        print(list)

C#

using System;
using System.Collections.Generic;
using System.Linq;

namespace CD056
{
    class Program
    {
        static void Main()
        {
            SortMethod srt = new SortMethod(new List<int>() { 5, 2, 4, 6, 1, 3 });

            string result = string.Join(", ", srt.DoInsertionSort());
            Console.WriteLine(result);
            Console.ReadKey();
        }
    }

    class SortMethod
    {
        private List<int> SourceList = new List<int>();

        private List<int> InsertionSortedList = new List<int>();

        public SortMethod(List<int> aList)
        {
            SourceList = aList;
            InsertionSortedList = aList;
        }

        // Insertion Sort 실행
        public List<int> DoInsertionSort()
        {
            // 각 인덱스의 값 및 좌측부분 리스트에 대해 삽입 정렬 ... (1)
            // (1) + 각 인덱스의 우측 부분 리스트 = 해당 인덱스까지 정렬된 리스트 ... (2)
            // (2)에 대해 계속해서 마지막 인덱스까지 상기 과정 반복
            for (int idx = 1; idx < SourceList.Count; idx++)
            {
                // 현재 인덱스의 좌측부 리스트 및 해당 인덱스의 값으로 삽입 정렬
                List<int> sortedPart = InsertValue(InsertionSortedList.GetRange(0, idx), SourceList[idx]);
                // 현재 인덱스의 우측부 리스트
                List<int> unsortedPart = SourceList.GetRange(idx + 1, SourceList.Count - (idx + 1));
                // 현재 인덱스에 대해 정렬된 좌측부 리스트 + 우측부 리스트
                InsertionSortedList = sortedPart.Concat(unsortedPart).ToList(); ;
            }
            return InsertionSortedList;
        }

        // 리스트(aList)와 값(aValue)가 주어졌을 때, 오름차순으로 aValue가 삽입된 리스트 반환
        private static List<int> InsertValue(List<int> aList, int aValue)
        {
            // aValue의 삽입 위치 계산
            int insertIdx = aList.Count; // 삽입 인덱스
            for (int idx = 0; idx < aList.Count; idx++)
            {
                if (aValue <= aList[idx])
                {
                    insertIdx = idx;
                    break;
                }
            }
            // 해당 위치에 aValue 삽입된 리스트 반환
            List<int> resultList = new List<int>();
            resultList.AddRange(aList.GetRange(0, insertIdx));
            resultList.Add(aValue);
            resultList.AddRange(aList.GetRange(insertIdx, aList.Count - insertIdx));
            return resultList;
        }
    }
}

def insort(lis):
    lis.insert(0,min(lis)-1)
    for x in range(1,len(lis)):
        for i in range(x-1,-1,-1):
            if lis[i] < lis[x]:
                break
        lis.insert(i+1,lis[x])
        del lis[x+1]
    print(lis[1:])

def Sort(numlist):
    idxlist = numlist.copy()
    idxlist.sort()
    samplelist = numlist.copy()

    for i in samplelist:
        numlist.remove(i)
        numlist.insert(i-1, i)
    return numlist
print(Sort([5,2,4,6,1,3]))

my_list = [5,2,4,6,1,3]
index_current=1
move_flag=0
insertion_position=0

while index_current<len(my_list):
    for i in range(index_current-1,-1,-1):
        if my_list[i]>my_list[index_current]:
            insertion_position=i
            move_flag=1
    if move_flag==1:
        my_list.insert(insertion_position,my_list.pop(index_current))
    index_current+=1
    move_flag=0

print(my_list)

data = [5, 2, 4, 6, 1, 3]
for i, num in enumerate(data) :
    cnt = 0
    for j in list(range(0, i)) :
        if num > data[i - j - 1] :
            break
        cnt = j + 1
    if cnt != 0 :
        for k in list(range(0, cnt)) :
            data[i - k] = data[i - k - 1]
        data[i - cnt] = num
    print("step", i, data)
print("result", data)

function soluition(N) {
    var input = N;

    for (var i = 0; i < input.length - 1; i++) {
        var key = input [i + 1];
        for (var j = i; j >= 0 && input[j] > key; j--) {
            input[j + 1] = input[j];
        }
        input[j + 1] = key;
    }
    console.log(input);
}

soluition([14, 3, 6, 10, 11]);

namespace codingdojang__
{
    class Program
    {
        static void Main(string[] args)
        {
            Sort(new List<int>(){ 5, 2, 4, 6, 1, 3 });
        }

        static void Sort(List<int> input)
        {

            List<string> list = new List<string> { };
            foreach (var i in input)
            {
                list.Add(i.ToString());
            }
            for(int i = 1; i < list.Count; i++)
            {
                for(int e = 0; e < list.Count; e++)
                {
                    if (int.Parse(list[i]) < int.Parse(list[e]))
                    {
                        list.Insert(e, list[i]);
                        list.RemoveAt(i + 1);
                        break;
                    }
                }
            }
            foreach(var i in list)
            {
                Console.Write(i + ' ');
            }
            Console.WriteLine();
        }
    }
}

num = [5, 2, 4, 6, 1, 3]

print(num)
for i in range(1, len(num)):
    for j in range(i):
        if num[i] < num[j]:
            num.insert(j, num[i])
            num.pop(i+1)
    if num[i] > num[(i-1)]:
        num.insert(i, num[i])
        num.pop(i+1)

        print(num)

a= [5,2,4,6,1,3,100,89,229,17,7,20,500,99]
for i in range(0, len(a)-1):
    if a[i] > a[i+1]:
        e = a[i]     
        a[i] = a[i+1]
        a[i+1] = e
    for j in range(i, -1, -1):
        if a[j] > a[j+1]:
            e = a[j]     
            a[j] = a[j+1]
            a[j+1] = e
print(a)

print(sorted(list(map(int,input().split()))))

솔직히 문제 이해 잘 못하겠어요...일단 이렇게만 해두고, 나중에 이해 되면 그 때 풀겠읍니다;;

Arr = [5, 2, 4, 6, 1, 3]

for i in range(len(Arr)): # i:0~5
    for j in range(i): # j:0~4 ex) i=5, j=2
        if Arr[j] > Arr[i]: # 인덱스 0~j 중에서 Arr[i]보다 큰 값이 있을 경우.
            temp = Arr[j]
            Arr[j] = Arr[i] 
            for k in range(i-1, j, -1): # ex) 4~3 (i=5, j=2)
                Arr[k+1] = Arr[k] # ex) 5<-4, 4<-3
            Arr[j+1] = temp # ex) 3<-2

print(Arr)

[5, 2, 4, 6, 1, 3]
[5, 2, 4, 6, 1, 3]
[2, 5, 4, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[1, 2, 4, 5, 6, 3]
[1, 2, 3, 4, 5, 6]

근래 푼 문제 중에 이게 가장 골 아팠습니다. 풀다보면 어째 산으로 가버리냐..

a = input()
a = [int(x) for x in a.split(',')]
b = []
for i in a:
    b.append(i)
    b.sort()
    for j in b:
        if j in a:
            a.remove(j)
    a.reverse()
    b.reverse()
    a.extend(b)
    a.reverse()
    print(a)

var insert = function(array, rightIndex, value){
for(var i = rightIndex; i >=0 && array[i] > value; i--){
array[i + 1] = array[i] } array[i] = value; 
}; 
var insertionSort = function(array){ 
for(var i = 1; i < array.length; i++){ 
insert(array, i-1, array[i]); 
} 
};

array = [5,2,8,4,0,3,6,9] 
console.log(insertionSort(array));```{.javascript}

""python""

def insertionSort(x): for size in range(1, len(x)): val = x[size] i = size while i > 0 and x[i-1] > val: x[i] = x[i-1] i -= 1 x[i] = val

a = [5,2,4,6,1,3] insertionSort(a) print(a)

data = [5,2,4,6,1,3]

for i in range(1,len(data)):
    temp = 0
    while True :
        if data[i-1] > data[i]:
            temp = data[i-1]
            data[i-1] = data[i]
            data[i] = temp

            if i == 1 :                
                None                
            else :
                i = i - 1
                continue
        break

    print(data)

import java.util.ArrayList;
import java.util.Collections;

public class InsertionSort {

    public static void main(String[] args) {

        int[] nums = {5,2,4,6,1,3};
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int k=0; k<nums.length; k++) {
            list.add(nums[k]);
        }
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        for(int i=0; i<nums.length; i++) {
            int num = nums.length+1;
            for(int j=i; j<nums.length; j++) {
                if(num>list.get(j)) {
                    num = list.get(j);
                    Collections.swap(list, j, i);
                }
                else {
                    num = num;
                }
            }
            list2.add(num);
        }
        System.out.println(list2);
    }
}

#include <iostream>
#include <vector>
using namespace std;
/*
1.배열의 두번째 인덱스부터 시작하여 시작한 인덱스(검정색 블록) 좌측의 항목 중 자신이 들어가야 할 위치를 판단.

2.좌측의 배열 요소들은 본인보다 좌측에 값이 삽입되어 들어올 경우 한칸씩 우측으로 이동한다. 
  단, 삽입되어 들어오는 요소(그림에서 검정색 블록)가 있던 인덱스(원래의 위치)까지만 이동한다.

3.마지막 인덱스까지 위 과정을 반복한다.
*/

void Print(int *arr, int size) {
    cout << "arr[] = {";
    for (int i = 0; i < size; i++) {
        if (i == size - 1) { cout << arr[i] << " } "; }
        else { cout << arr[i] << " , "; }
    }
}

void Isort(int *arr, int size) {
    vector<pair<int, int>> v;;
    int cIdx;
    int temp;

    for (int i = 1; i < size; i++) {
        for (int j = 0; j < i; j++) {
            v.push_back(make_pair(arr[j], j));
        }
        cIdx = INT_MAX;
        temp = arr[i];
        for (vector<pair<int, int>>::reverse_iterator rter = v.rbegin(); rter != v.rend(); rter++) {
            if (rter->first > arr[i]) { cIdx = rter->second; }
            else { break; }
        }

        Print(arr, size);
        if (cIdx != INT_MAX) {
            cout << arr[i] << "가 들어가야 할 위치는" << cIdx << "인덱스 이다." << endl;
            for (int j = i; j > cIdx; j--) {
                cout << j - 1 << "번 인덱스인" << arr[j - 1] << "을 한칸뒤로. . . ";
                arr[j] = arr[j - 1];
            }
            cout << endl;
            arr[cIdx] = temp;
        }
        else { cout << arr[i] << "는 굳이 옮길 필요가 없는듯?" << endl; }
    }
    cout << endl;
    cout << "정렬 완료!" << endl;
    Print(arr, size);
}

int main() {
    int arr[] = { 5,2,4,6,1,3 };
    int size = sizeof(arr) / sizeof(int);

    Isort(arr, size);
}

#파이썬
#입력은 0~10 범위의 10개의 정수를 랜덤으로 생성하였습니다

from random import *
a=[]
for i in range (10):
    a.append(randint(0,10))
print ('input=',a)

i=1
while (i<len(a)):
    j=i
    while (j>0):
        if a[j-1]>a[j]:
            temp=a[j]
            a[j]=a[j-1]
            a[j-1]=temp           
        else:
            break
        j-=1
    i+=1

print ('output=',a)

def sort_A(s):
    for i in range(1, len(s)):
        cnt = 0
        for j in range(i, 0, -1):
            if (s[j-1] > s[i]):
                cnt += 1
            continue
        m = s[i]
        s[(i-cnt+1):(i+1)] = s[(i-cnt):i]
        s[i-cnt] = m
    return s

def main():
   sort_array = [9, 5, 1, 6, 4, 3, 7, 8, 2]
   print(sort_A(sort_array))

if __name__ == '__main__':
    main()

def insert_sort(arr):
    for i in range(1,len(arr)):
        key=arr[i]
        j=i-1
        while arr[j]>key and j>=0:
            arr[j+1]=arr[j]
            j -=1
        arr[j+1]=key
    return arr

print(insert_sort([5,2,3,6,1,4]))

lst=list(map(int,input("배열을 입력하십시오: ").split(",")))
i=1
while lst!=sorted(lst):    #입력한 배열이 정렬된 배열과 같지 않을 때 까지,
    if lst[i]<lst[i-1]:    #lst의 i번째 요소가 lst의 i-1번째 요소보다 작으면
        lst=sorted(lst[:i+1])+lst[i+1:]    #리스트=처음부터 i번째 요소까지 정렬한 리스트 + (i+1)부터의 리스트
    print(lst) #출력
    i+=1

결과

배열을 입력하십시오: 5,2,4,6,1,3
[2, 5, 4, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[2, 4, 5, 6, 1, 3]
[1, 2, 4, 5, 6, 3]
[1, 2, 3, 4, 5, 6]

루프를 5번 돌게했고 정렬도 성공했는데, Insertion Sort가 맞는지는 모르겠네요....

n = list(input())
for j in range(1,len(n)):
    for i in range(0,j):
        while n[j] < n[i]:
            n[i],n[j] = n[j],n[i]

print(n)

# Insertion sort
arr = [5,2,4,6,1,3]
for i in range(1, len(arr)):
    for j in range(i):
        if arr[j] > arr[i]:
            tmp = arr[i]
            arr.pop(i)
            arr.insert(j, tmp)
print(arr)

def Insertion_Sort(L):
    for i in range(len(L)-1):
        for j in range(len(L)-1):
            if L[j]>L[j+1]:
                L[j],L[j+1]=L[j+1],L[j]
    print(L)

a= input("> ").split()
a=[int(i) for i in a]
Insertion_Sort(a)

def insertSort(s):
    result = s
    for i in range(1, len(result)):  # i번째 정렬
        for k in range(i, 0, -1):  # i번째 k번 바꾸기
            if result[k - 1] > result[k]:
                temp = result[k]
                result[k] = result[k-1]
                result[k-1] = temp
    print(result)


insertSort([5, 2, 4, 6, 1, 3])

def Insertion_Sort(list):

  for i in range(1,len(list),1):

    for j in range(0,i,1):

      if list[i]<list[j]:

        list[i],list[j]=list[j],list[i]

  return list

list=[5,2,4,6,1,3]

print(Insertion_Sort(list))

def sorting(_list):
    temp = [int(a) for a in _list]
    for i in range(len(temp)):
        for j in range(len(temp)):
            while temp[i] > temp[j]:
                temp[i], temp[j] = temp[j], temp[i]
                print('{} and {} swapped'.format(temp[j], temp[i]),temp)

    print(temp)

sorting([4,3,2,1])

def Insert(data):
    for i in range(len(data)):
        if i+1==len(data):
            break
        elif  data[i]<data[i+1] :
            pass
        else: 
            for j in range(i+1):
                if data[j]<data[i+1]:
                    continue
                else:
                    temp1 = data[i+1]
                    temp2 = data[j]
                    data[i+1]=temp2
                    data[j]=temp1    
    print(data)

Insert([5,2,4,6,1,3])

tmp = [5, 2, 4, 6, 1, 3]

print('0 :', tmp)
for i in range(1, len(tmp)):
    idx = i
    for j in range(i, -1, -1):
        if tmp[j] > tmp[i]:
            idx = j
    v = tmp.pop(i)
    tmp.insert(idx, v)
    print(i, ':', tmp)

print('sorted: ', tmp)

list1 = [5, 2, 4, 6, 1, 3]


def makeAns(list_):
    for i in range(1, len(list_)):
        for j in range(0, i):
            if list_[i] < list_[j]:
                tmp = list_[i]
                for k in range(i, j, -1):
                    list_[k] = list_[k-1]
                list_[j] = tmp

    print(list_)


makeAns(list1)

결과 : [1, 2, 3, 4, 5, 6]

array = [5,2,4,6,1,3]
while array != sorted(array):
    for i in range(1,len(array)):
        for j in range(i):
            if array[i] < array[j]:
                array[j], array[i] = array[i], array[j]
print(array)

a=[5,2,4,6,1,3,25,252,5414,414,24,0,13]
for i in range(1,len(a)):
    for j in range(i,0,-1):
        if a[j-1]>a[j]:
                temp=a[j-1]
                a[j-1]=a[j]
                a[j]=temp
print(a)

#codingdojing_insertion sort

ori = [5, 2, 4, 6, 1, 3]

for i in range(1,len(ori)): # start from second number
    j = i-1
    while True:
        if j >= 0:
            if ori[j] > ori[i]: 
                j -= 1
            else: 
                ori.insert(j+1, ori.pop(i))
                break
        else:   # j == -1
            ori.insert(0, ori.pop(i))
            break

print(ori)

처음에 swap으로 했다가.. insertion sort가 아니라는 말을 보고 새로 짜 보았습니다.

list=[5,2,4,6,1,3]
for i, name in enumerate(list[1:]):
    copylist=list[:] #리스트 연동을 막기 위해 복사
    del copylist[i+1] #옮기고자 하는 리스트 요소를 지움. 이때 i는 enumerate 기준이므로 copylist에선 i+1 사용
    for j in range(0,i+1):
        if list[j]<name: pass
        else:
            list=copylist[0:j]+[name]+copylist[j:]
            break
    print(list)

def insertion_sort(array,index=1):
    for i in range(index,0,-1):
        if array[i] < array[i-1] : array[i],array[i-1] = array[i-1], array[i]
        else : break
    if index != len(array)-1 : return insertion_sort(array,index+1)
    else : return array

print(insertion_sort([5,2,4,6,1,3]))

// Rust

// vector를 자르고, 당기고 밀고 보다는 swap이 더 효율적이나, 문제가 요구하는대로 작성했습니다

fn insertion_sort(vec_: Vec) -> Vec {

let mut vec = vec_;
for i in 1..vec.len() {
    let rem = vec.split_off(i+1);
    for j in 0..i {
        if vec[i] < vec[j] {        //find insertion index
            let v = vec.remove(i);
            vec.insert(j, v);
            break;
        }
    }
    vec.extend(rem);
    println!("{:?}", vec);
}
vec

}

a = [5,2,4,6,1,3]
n = 0
print(a)
j = [a[i+1] < a[i] for i in range(len(a)-1)]

while sum(j) != (len(a)-1):
    n=n+1
    for i in range(len(a)-1):
        if a[i] > a[i+1]:
            a[i],a[i+1] = a[i+1],a[i]
    j = [a[i+1]-a[i] for i in range(len(a)-1)]   

    print(f'{a}  try number: {n} ')

반 어거지로 만들었는거 같아요  ㅋ..

def IS(a):
    n = 0
    for i in range(1,len(a)):
        if a[i] <= a[i-1]:
            n = a[i]
            a[i] = a[i-1]
            a[i-1] = n
            a[:i] = sorted(a[:i])

l = [5, 2, 4, 6, 1, 3]
m =0
for i in range(1, len(l)):
    for k in range(i):
        if l[k] > l[i]:
            l.insert(k,l[i])
            l.pop(i+1)
            m +=1
            print(l,'{}회차'.format(m))
            break

print(l,'최종')

import random

arr_sort = []
count = 0

while(1):
    ran_num = random.randrange(1, 10)
    if ran_num not in arr_sort:
        arr_sort.append(ran_num)
        count += 1

    if count == 5:
        break

for i in range(1, len(arr_sort)):
    for ix in range(len(arr_sort)-1):
        if arr_sort[i] < arr_sort[ix]:
            arr_num = arr_sort[i]
            arr_sort.remove(arr_sort[i])
            arr_sort.insert(ix, arr_num)
            break

print(arr_sort)