线性表常见算法实现
struct seqlist
{
int * a;
int size;
} ;
void init_seqlist ( seqlist* l, int n)
{
l-> a = ( int * ) malloc ( sizeof ( int ) * n) ;
l-> size = n;
}
void reverse_seqlist ( seqlist* l)
{
for ( int i = 0 , j = l-> size- 1 ; i <= j; ++ i, -- j)
{
int tmp = l-> a[ i] ;
l-> a[ i] = l-> a[ j] ;
l-> a[ j] = tmp;
}
}
设计一个算法,从一给定的顺序表L中删除下标i~j(i<=j,包括i,j)的所有元素,假定i,j都是合法的。
void delete_i_to_j ( seqlist* l, int i, int j)
{
for ( int p = j + 1 , e= i; p < l-> size; ++ p, ++ e)
{
l-> a[ e] = l-> a[ p] ;
}
l-> size - = j - i + 1 ;
}
有一个顺序表L,其元素为整型数据,设计一个算法,将L中所有小于表头元素的整数放在前半部分,大于表头元素的整数放在后半部分 。
void compare_with_head ( seqlist* l)
{
int loc = 0 ;
for ( int i = 1 ; i < l-> size; ++ i)
{
if ( l-> a[ i] < l-> a[ loc] )
{
int value = l-> a[ i] ;
for ( int j = i ; j> loc; -- j)
{
l-> a[ j ] = l-> a[ j- 1 ] ;
}
l-> a[ loc++ ] = value;
}
}
}
有一个递增非空单链表,设计一个算法删除值域重复的结点 。
struct node
{
int data;
struct node* next;
} ;
struct linked_list
{
struct node* head;
} ;
void linked_list_push ( linked_list* l, int x)
{
struct node* p = ( struct node* ) malloc ( sizeof ( struct node) ) ;
p-> data = x;
p-> next = NULL ;
if ( l-> head == NULL )
{
l-> head = p;
}
else
{
struct node* q = l-> head;
while ( q-> next != NULL )
{
q = q-> next;
}
q-> next = p;
}
}
void print_linked_list ( linked_list l)
{
struct node* q = l. head;
while ( q != NULL )
{
printf ( "%d " , q-> data) ;
q = q-> next;
}
printf ( "\n" ) ;
}
void delete_repeating_elements ( linked_list* l)
{
struct node* p = l-> head-> next;
struct node* q = l-> head;
while ( p != NULL )
{
if ( p-> data == q-> data)
{
struct node* r = p;
q-> next = p-> next;
p = p-> next;
free ( r) ;
}
else
{
p = p-> next;
q = q-> next;
}
}
}
设计一个算法删除单链表L (有头结点)中的最小值结点 。
void delete_linked_list_min ( linked_list* l)
{
int min_value = 1000000 ;
struct node* p = l-> head;
while ( p-> next != NULL )
{
if ( p-> data < min_value)
{
min_value = p-> data;
}
p = p-> next;
}
p = l-> head;
struct node* q = p-> next;
while ( p-> next != NULL )
{
if ( q-> data == min_value)
{
struct node* r = q;
p-> next = q-> next;
q = p-> next;
free ( r) ;
}
else
{
p = p-> next;
q = p-> next;
}
}
if ( l-> head-> data == min_value)
{
struct node* r = l-> head;
l-> head = l-> head-> next;
free ( r) ;
}
}
单链表L,设计一个算法将其逆置,要求不能建立新结点,只能通过表中已有结点的重新组合来完成。
void reverse_linked_list ( linked_list* l)
{
struct node* p;
struct node* q;
struct node* r;
p = l-> head;
q = p-> next;
r = q-> next;
while ( r-> next != NULL )
{
q-> next = p;
p = q;
q = r;
r = r-> next;
}
q-> next = p;
r-> next = q;
l-> head-> next = NULL ;
l-> head = r;
}
设计个算法, 将一个头结点为A的单链表(其数据域为整数),分解成两个单链表A和B,便得A链表只含有原来链表中data域为奇数的结点,而B链表只含有原链表中data域为偶数的结点,且保持原来的相对顺序。